Struct Thread 

pub struct Thread { /* private fields */ }

A non-owning Luau thread handle.

Thread does not keep the VM alive and does not encode exclusive access to the VM stack. It is deliberately !Send and !Sync through its raw state representation.

Safety model for unsafe methods

Unless a method documents stricter requirements, every unsafe Thread operation requires a live thread belonging to a live VM. Stack indices, stack shapes, counts, tags, and pointer arguments must satisfy the corresponding Luau API operation’s contract. The caller must provide sufficient stack capacity where the operation does not grow the stack, prevent reentrant or concurrent access to VM-owned records, and treat any operation that can allocate or execute code as a possible GC transition. Returned pointers and raw handles are non-owning and may be invalidated by stack relocation, collection, closure, reset, or VM destruction.

Implementations

impl Thread

pub unsafe fn open_base(&self) -> NativeCallResult

luaopen_base

impl Thread

pub unsafe fn open_bit32(&self) -> NativeCallResult

luaopen_bit32

impl Thread

pub unsafe fn open_buffer(&self) -> NativeCallResult

luaopen_buffer

impl Thread

pub unsafe fn open_class(&self) -> NativeCallResult

luaopen_class

impl Thread

pub unsafe fn open_coroutine(&self) -> NativeCallResult

luaopen_coroutine

impl Thread

pub unsafe fn open_debug(&self) -> NativeCallResult

luaopen_debug

impl Thread

pub unsafe fn open_integer(&self) -> NativeCallResult

luaopen_integer

impl Thread

pub unsafe fn open_math(&self) -> NativeCallResult

luaopen_math

impl Thread

pub unsafe fn open_os(&self) -> NativeCallResult

luaopen_os

impl Thread

pub unsafe fn open_string(&self) -> NativeCallResult

luaopen_string

impl Thread

pub unsafe fn open_table(&self) -> NativeCallResult

luaopen_table

impl Thread

pub unsafe fn open_utf8(&self) -> NativeCallResult

luaopen_utf8

impl Thread

pub unsafe fn open_vector(&self) -> NativeCallResult

luaopen_vector

impl Thread

pub unsafe fn open_libs(&self) -> NativeCallResult

luaL_openlibs

impl Thread

pub unsafe fn load( &self, chunk_name: impl AsRef<[u8]>, data: impl AsRef<[u8]>, env: i32, ) -> VmResult

luau_load

Safety

The thread and its VM must remain live and satisfy Thread’s shared unsafe API contract. env must identify a valid environment table or accepted pseudo-index for this VM, and data must be bytecode for the targeted Luau release.

impl Thread

pub unsafe fn push_where(&self, level: i32) -> VmErrorResult

luaL_where

pub unsafe fn lua_error<'a, T>( &self, format: impl AsRef<[u8]>, args: impl AsMut<[Arg<'a>]>, ) -> VmErrorResult<T>

luaL_error

pub unsafe fn lua_type_error<T>( &self, argument: i32, expected_type: impl AsRef<[u8]>, ) -> VmErrorResult<T>

luaL_typeerror

pub unsafe fn lua_arg_expected( &self, condition: bool, argument: i32, expected_type: &str, ) -> VmErrorResult

luaL_argexpected

pub unsafe fn lua_arg_error<T>( &self, argument: i32, message: impl AsRef<[u8]>, ) -> VmErrorResult<T>

luaL_argerror

impl Thread

pub unsafe fn lua_check_stack( &self, size: i32, message: Option<&str>, ) -> VmErrorResult

luaL_checkstack

pub unsafe fn check_type( &self, argument: i32, expected_type: i32, ) -> VmErrorResult

luaL_checktype

pub unsafe fn check_any(&self, argument: i32) -> VmErrorResult

luaL_checkany

pub unsafe fn check_string(&self, argument: i32) -> VmErrorResult<&BStr>

luaL_checklstring

pub unsafe fn opt_string(&self, argument: i32) -> VmErrorResult<Option<&BStr>>

luaL_optlstring

pub unsafe fn check_buffer( &self, argument: i32, ) -> VmErrorResult<(*mut u8, usize)>

luaL_checkbuffer

pub unsafe fn check_userdata( &self, argument: i32, type_name: &str, ) -> VmErrorResult<*mut ()>

luaL_checkudata

pub unsafe fn check_userdata_tagged( &self, argument: i32, tag: i32, ) -> VmErrorResult<*mut ()>

luaL_checkudatatagged

pub unsafe fn check_number(&self, argument: i32) -> VmErrorResult<f64>

luaL_checknumber

pub unsafe fn opt_number( &self, argument: i32, default: f64, ) -> VmErrorResult<f64>

luaL_optnumber

pub unsafe fn check_boolean(&self, argument: i32) -> VmErrorResult<i32>

luaL_checkboolean

pub unsafe fn opt_boolean( &self, argument: i32, default: i32, ) -> VmErrorResult<i32>

luaL_optboolean

pub unsafe fn check_integer(&self, argument: i32) -> VmErrorResult<i32>

luaL_checkinteger

pub unsafe fn opt_integer( &self, argument: i32, default: i32, ) -> VmErrorResult<i32>

luaL_optinteger

pub unsafe fn check_integer64(&self, argument: i32) -> VmErrorResult<i64>

luaL_checkinteger64

pub unsafe fn opt_integer64( &self, argument: i32, default: i64, ) -> VmErrorResult<i64>

luaL_optinteger64

pub unsafe fn check_unsigned(&self, argument: i32) -> VmErrorResult<u32>

luaL_checkunsigned

pub unsafe fn opt_unsigned( &self, argument: i32, default: u32, ) -> VmErrorResult<u32>

luaL_optunsigned

pub unsafe fn check_vector(&self, argument: i32) -> VmErrorResult<[f32; 3]>

luaL_checkvector

pub unsafe fn opt_vector( &self, argument: i32, ) -> VmErrorResult<Option<[f32; 3]>>

luaL_optvector

pub unsafe fn check_option( &self, argument: i32, default: Option<&str>, options: &[&str], ) -> VmErrorResult<i32>

luaL_checkoption

impl Thread

pub unsafe fn lua_type_name(&self, index: i32) -> LuaString

luaL_typename

pub unsafe fn lua_to_string(&self, index: i32) -> VmResult<&BStr>

luaL_tolstring

impl Thread

pub unsafe fn push_native_closure_k( &self, function: RawNativeFunction, debug_name: Option<&'static str>, upvalues: i32, continuation: Option<RawNativeContinuation>, ) -> VmErrorResult

lua_pushcclosurek

pub unsafe fn push_native_function( &self, function: RawNativeFunction, debug_name: Option<&'static str>, ) -> VmErrorResult

lua_pushcfunction

pub unsafe fn push_native_closure( &self, function: RawNativeFunction, debug_name: Option<&'static str>, upvalues: i32, ) -> VmErrorResult

lua_pushcclosure

pub unsafe fn to_native_function(&self, index: i32) -> Option<RawNativeFunction>

lua_tocfunction

pub unsafe fn clone_function(&self, index: i32) -> VmErrorResult

lua_clonefunction

pub unsafe fn uses_export(&self, index: i32) -> i32

lua_usesexport

impl Thread

pub unsafe fn call(&self, n_args: i32, n_results: i32) -> VmResult

lua_call

pub unsafe fn protected_call( &self, n_args: i32, n_results: i32, errfunc: i32, ) -> VmResult

lua_pcall

pub unsafe fn protected_native_call( &self, function: RawNativeFunction, userdata: *mut (), ) -> VmResult

lua_cpcall

pub unsafe fn error<T>(&self) -> VmErrorResult<T>

lua_error

pub unsafe fn yield_current(&self, results: i32) -> NativeCallResult

lua_yield

pub unsafe fn break_current(&self) -> NativeCallResult

lua_break

impl Thread

pub unsafe fn resume(&self, from: Option<&Thread>, nargs: i32) -> VmResult

lua_resume

pub unsafe fn resume_error(&self, from: Option<&Thread>) -> VmResult

lua_resumeerror

impl Thread

pub unsafe fn call_yieldable( &self, nargs: i32, nresults: i32, ) -> NativeCallResult

luaL_callyieldable

pub unsafe fn protected_call_yieldable( &self, nargs: i32, nresults: i32, errfunc: i32, ) -> NativeCallResult

luaL_pcallyieldable

impl Thread

pub unsafe fn call_hook<F>(&self, hook: F, userdata: *mut ()) -> VmResult

where F: FnOnce(&Thread, &mut LuaDebug) -> VmResult,

lua_callhook

pub unsafe fn stack_depth(&self) -> i32

lua_stackdepth

pub unsafe fn get_info( &self, level: i32, what: &str, ar: &mut LuaDebug, ) -> VmErrorResult<i32>

lua_getinfo

pub unsafe fn get_argument( &self, level: i32, argument: i32, ) -> VmErrorResult<i32>

lua_getargument

pub unsafe fn get_local( &self, level: i32, local: i32, ) -> VmErrorResult<Option<LuaString>>

lua_getlocal

pub unsafe fn set_local(&self, level: i32, local: i32) -> Option<LuaString>

lua_setlocal

pub unsafe fn get_upvalue( &self, function_index: i32, upvalue_index: i32, ) -> VmErrorResult<Option<LuaString>>

lua_getupvalue

pub unsafe fn set_upvalue( &self, function_index: i32, upvalue_index: i32, ) -> Option<LuaString>

lua_setupvalue

pub unsafe fn single_step(&self, enabled: i32)

lua_singlestep

pub unsafe fn breakpoint( &self, function_index: i32, line: i32, enabled: i32, ) -> VmErrorResult<i32>

lua_breakpoint

pub unsafe fn has_custom_execution(&self, level: i32) -> i32

lua_hascustomexecution

pub unsafe fn in_custom_execution(&self, level: i32) -> i32

lua_incustomexecution

pub unsafe fn at_breakpoint(&self) -> i32

lua_atbreakpoint

pub unsafe fn get_coverage( &self, function_index: i32, context: *mut (), callback: LuaCoverage, ) -> VmErrorResult

lua_getcoverage

pub unsafe fn get_counters( &self, function_index: i32, context: *mut (), function_visit: LuaCounterFunction, counter_visit: LuaCounterValue, )

lua_getcounters

pub unsafe fn debug_trace(&self) -> VmErrorResult<BString>

lua_debugtrace

impl Thread

pub unsafe fn traceback( &self, source: Option<&Thread>, message: Option<&BStr>, level: i32, ) -> VmErrorResult

luaL_traceback

impl Thread

pub unsafe fn gc(&self, what: i32, data: i32) -> VmErrorResult<i32>

lua_gc

pub unsafe fn memory_dump( &self, output: &mut BString, category_name: Option<&mut dyn GcCategoryNamer>, )

lua_memorydump

pub unsafe fn allocation_rate(&self) -> i64

lua_allocationrate

pub unsafe fn set_mem_cat(&self, category: i32)

lua_setmemcat

pub unsafe fn total_bytes(&self, category: i32) -> usize

lua_totalbytes

impl Thread

pub unsafe fn abs_index(&self, index: i32) -> i32

lua_absindex

pub unsafe fn get_top(&self) -> i32

lua_gettop

pub unsafe fn check_stack(&self, size: i32) -> i32

lua_checkstack

pub unsafe fn raw_check_stack(&self, size: i32) -> VmErrorResult

lua_rawcheckstack

pub unsafe fn set_top(&self, index: i32) -> VmErrorResult

lua_settop

pub unsafe fn restore_top(&self, top: i32)

Restores the stack top to a previous absolute top.

pub unsafe fn pop(&self, count: i32)

lua_pop

pub unsafe fn push_value(&self, index: i32) -> VmErrorResult

lua_pushvalue

pub unsafe fn remove(&self, index: i32)

lua_remove

pub unsafe fn insert(&self, index: i32)

lua_insert

pub unsafe fn replace(&self, index: i32)

lua_replace

pub unsafe fn x_move(&self, to: &Thread, count: i32) -> VmErrorResult

lua_xmove

pub unsafe fn x_push(&self, to: &Thread, index: i32) -> VmErrorResult

lua_xpush

impl Thread

pub unsafe fn push_nil(&self) -> VmErrorResult

lua_pushnil

pub unsafe fn push_number(&self, value: f64) -> VmErrorResult

lua_pushnumber

pub unsafe fn push_integer(&self, value: i32) -> VmErrorResult

lua_pushinteger

pub unsafe fn push_integer64(&self, value: i64) -> VmErrorResult

lua_pushinteger64

pub unsafe fn push_unsigned(&self, value: u32) -> VmErrorResult

lua_pushunsigned

pub unsafe fn push_vector(&self, components: [f32; 3]) -> VmErrorResult

lua_pushvector

pub unsafe fn push_boolean(&self, value: i32) -> VmErrorResult

lua_pushboolean

pub unsafe fn push_light_userdata_tagged( &self, pointer: *mut (), tag: i32, ) -> VmErrorResult

lua_pushlightuserdatatagged

pub unsafe fn push_light_userdata(&self, pointer: *mut ()) -> VmErrorResult

lua_pushlightuserdata

pub unsafe fn push_string(&self, bytes: impl AsRef<[u8]>) -> VmErrorResult

lua_pushlstring

pub unsafe fn push_optional_string( &self, bytes: Option<impl AsRef<[u8]>>, ) -> VmErrorResult

lua_pushstring

pub unsafe fn push_vfstring<'a>( &self, format: &str, args: impl AsMut<[Arg<'a>]>, ) -> VmErrorResult<LuaString>

lua_pushvfstring

pub unsafe fn push_fstring<'a>( &self, format: &str, args: impl AsMut<[Arg<'a>]>, ) -> VmErrorResult<LuaString>

lua_pushfstring

impl Thread

pub unsafe fn is_number(&self, index: i32) -> i32

lua_isnumber

pub unsafe fn is_string(&self, index: i32) -> i32

lua_isstring

pub unsafe fn is_light_userdata(&self, index: i32) -> i32

lua_islightuserdata

pub unsafe fn is_function(&self, index: i32) -> i32

lua_isfunction

pub unsafe fn is_table(&self, index: i32) -> i32

lua_istable

pub unsafe fn is_nil(&self, index: i32) -> i32

lua_isnil

pub unsafe fn is_boolean(&self, index: i32) -> i32

lua_isboolean

pub unsafe fn is_vector(&self, index: i32) -> i32

lua_isvector

pub unsafe fn is_thread(&self, index: i32) -> i32

lua_isthread

pub unsafe fn is_buffer(&self, index: i32) -> i32

lua_isbuffer

pub unsafe fn is_none(&self, index: i32) -> i32

lua_isnone

pub unsafe fn is_none_or_nil(&self, index: i32) -> i32

lua_isnoneornil

pub unsafe fn is_class(&self, index: i32) -> i32

lua_isclass

pub unsafe fn is_object(&self, index: i32) -> i32

lua_isobject

pub unsafe fn is_integer64(&self, index: i32) -> i32

lua_isinteger64

pub unsafe fn is_native_function(&self, index: i32) -> i32

lua_iscfunction

pub unsafe fn is_lua_function(&self, index: i32) -> i32

lua_isLfunction

pub unsafe fn is_userdata(&self, index: i32) -> i32

lua_isuserdata

pub unsafe fn type_of(&self, index: i32) -> i32

lua_type

pub unsafe fn type_name(&self, tag: i32) -> LuaString

lua_typename

pub unsafe fn equal(&self, left: i32, right: i32) -> VmResult<i32>

lua_equal

pub unsafe fn raw_equal(&self, left: i32, right: i32) -> i32

lua_rawequal

pub unsafe fn less_than(&self, left: i32, right: i32) -> VmResult<i32>

lua_lessthan

pub unsafe fn to_number(&self, index: i32) -> Option<f64>

lua_tonumberx

pub unsafe fn to_integer(&self, index: i32) -> Option<i32>

lua_tointegerx

pub unsafe fn to_unsigned(&self, index: i32) -> Option<u32>

lua_tounsignedx

pub unsafe fn to_vector(&self, index: i32) -> Option<[f32; 3]>

lua_tovector

pub unsafe fn to_boolean(&self, index: i32) -> i32

lua_toboolean

pub unsafe fn to_integer64(&self, index: i32) -> Option<i64>

lua_tointeger64

pub unsafe fn to_string(&self, index: i32) -> VmErrorResult<Option<&BStr>>

lua_tostring

pub unsafe fn to_string_atom(&self, index: i32) -> Option<(&BStr, i32)>

lua_tostringatom

pub unsafe fn namecall_atom(&self) -> Option<(&BStr, i32)>

lua_namecallatom

pub unsafe fn len(&self, index: i32) -> VmResult<f64>

Numeric result of the Luau length operator (#).

pub unsafe fn obj_len(&self, index: i32) -> i32

lua_objlen

pub unsafe fn to_pointer(&self, index: i32) -> *const ()

lua_topointer

impl Thread

pub unsafe fn new_buffer(&self, size: usize) -> VmErrorResult<*mut u8>

lua_newbuffer

pub unsafe fn to_buffer(&self, index: i32) -> Option<(*mut u8, usize)>

lua_tobuffer

impl Thread

pub unsafe fn create_table( &self, array_size: usize, record_size: usize, ) -> VmErrorResult

lua_createtable

pub unsafe fn new_table(&self) -> VmErrorResult

lua_newtable

pub unsafe fn get_table(&self, index: i32) -> VmResult<i32>

lua_gettable

pub unsafe fn get_field( &self, index: i32, key: impl AsRef<[u8]>, ) -> VmResult<i32>

lua_getfield

pub unsafe fn get_global(&self, name: impl AsRef<[u8]>) -> VmResult<i32>

lua_getglobal

pub unsafe fn raw_get_field( &self, index: i32, key: impl AsRef<[u8]>, ) -> VmErrorResult<i32>

lua_rawgetfield

pub unsafe fn raw_get(&self, index: i32) -> i32

lua_rawget

pub unsafe fn raw_geti(&self, index: i32, key: i32) -> VmErrorResult<i32>

lua_rawgeti

pub unsafe fn raw_getp_tagged( &self, index: i32, key: *mut (), tag: i32, ) -> VmErrorResult<i32>

lua_rawgetptagged

pub unsafe fn raw_getp(&self, index: i32, key: *mut ()) -> VmErrorResult<i32>

lua_rawgetp

pub unsafe fn set_readonly(&self, index: i32, enabled: i32)

lua_setreadonly

pub unsafe fn get_readonly(&self, index: i32) -> i32

lua_getreadonly

pub unsafe fn set_safe_env(&self, index: i32, enabled: i32)

lua_setsafeenv

pub unsafe fn get_metatable(&self, index: i32) -> VmErrorResult<i32>

lua_getmetatable

pub unsafe fn get_fenv(&self, index: i32) -> VmErrorResult

lua_getfenv

pub unsafe fn set_table(&self, index: i32) -> VmResult

lua_settable

pub unsafe fn set_field(&self, index: i32, key: impl AsRef<[u8]>) -> VmResult

lua_setfield

pub unsafe fn raw_set_field( &self, index: i32, key: impl AsRef<[u8]>, ) -> VmErrorResult

lua_rawsetfield

pub unsafe fn set_global(&self, name: impl AsRef<[u8]>) -> VmErrorResult

lua_setglobal

pub unsafe fn concat(&self, count: i32) -> VmResult

lua_concat

pub unsafe fn raw_set(&self, index: i32) -> VmErrorResult

lua_rawset

pub unsafe fn raw_seti(&self, index: i32, key: i32) -> VmErrorResult

lua_rawseti

pub unsafe fn raw_setp_tagged( &self, index: i32, key: *mut (), tag: i32, ) -> VmErrorResult

lua_rawsetptagged

pub unsafe fn raw_setp(&self, index: i32, key: *mut ()) -> VmErrorResult

lua_rawsetp

pub unsafe fn set_metatable(&self, index: i32) -> VmErrorResult<i32>

lua_setmetatable

pub unsafe fn set_fenv(&self, index: i32) -> i32

lua_setfenv

pub unsafe fn next(&self, index: i32) -> VmErrorResult<i32>

lua_next

pub unsafe fn raw_iter(&self, index: i32, iter: i32) -> VmErrorResult<i32>

lua_rawiter

pub unsafe fn clear_table(&self, index: i32) -> VmErrorResult

lua_cleartable

pub unsafe fn clone_table(&self, index: i32) -> VmErrorResult

lua_clonetable

impl Thread

pub unsafe fn get_ref(&self, reference: i32) -> VmErrorResult<i32>

lua_getref

pub unsafe fn ref_value(&self, index: i32) -> VmErrorResult<i32>

lua_ref

pub unsafe fn unref_value(&self, reference: i32) -> i32

lua_unref

pub unsafe fn weak_ref_value(&self, index: i32) -> VmErrorResult<i32>

lua_weakref

pub unsafe fn weak_unref_value(&self, reference: i32) -> i32

lua_weakunref

pub unsafe fn get_weak_ref(&self, reference: i32) -> VmErrorResult<i32>

lua_getweakref

impl Thread

pub unsafe fn get_metafield( &self, index: i32, event: &str, ) -> VmErrorResult<i32>

luaL_getmetafield

pub unsafe fn call_meta(&self, object: i32, event: &str) -> VmResult<i32>

luaL_callmeta

pub unsafe fn new_metatable(&self, table_name: &str) -> VmErrorResult<i32>

luaL_newmetatable

pub unsafe fn find_table<'a, T>( &self, index: i32, name: &'a T, size_hint: usize, ) -> VmErrorResult<Option<&'a [u8]>>

where T: AsRef<[u8]> + ?Sized,

luaL_findtable

pub unsafe fn register( &self, library_name: Option<&str>, functions: &[NativeFunction], ) -> VmResult

luaL_register

pub unsafe fn register_module(&self, module: &NativeModule) -> VmResult

impl Thread

pub unsafe fn sandbox(&self) -> VmErrorResult

luaL_sandbox

Safety

The caller must ensure that the current globals table can be made readonly and marked as a safe environment for future loads.

pub unsafe fn sandbox_thread(&self) -> VmErrorResult

luaL_sandboxthread

Safety

The caller must ensure that the thread can have its globals table replaced. If bytecode is loaded into the same sandboxed thread environment more than once, the caller must clear safeenv before the later load or install a fresh sandboxed environment first.

impl Thread

pub unsafe fn new_userdata_tagged( &self, size: usize, tag: i32, ) -> VmErrorResult<*mut ()>

lua_newuserdatatagged

pub unsafe fn new_userdata_tagged_with_metatable( &self, size: usize, tag: i32, ) -> VmErrorResult<*mut ()>

lua_newuserdatataggedwithmetatable

pub unsafe fn new_userdata_dtor( &self, size: usize, destructor: LuaInlineDestructor, ) -> VmErrorResult<*mut ()>

lua_newuserdatadtor

pub unsafe fn new_userdata(&self, size: usize) -> VmErrorResult<*mut ()>

lua_newuserdata

pub unsafe fn to_light_userdata(&self, index: i32) -> *mut ()

lua_tolightuserdata

pub unsafe fn to_light_userdata_tagged(&self, index: i32, tag: i32) -> *mut ()

lua_tolightuserdatatagged

pub unsafe fn to_userdata(&self, index: i32) -> *mut ()

lua_touserdata

pub unsafe fn to_userdata_tagged(&self, index: i32, tag: i32) -> *mut ()

lua_touserdatatagged

pub unsafe fn userdata_tag(&self, index: i32) -> i32

lua_userdatatag

pub unsafe fn light_userdata_tag(&self, index: i32) -> i32

lua_lightuserdatatag

pub unsafe fn set_userdata_tag(&self, index: i32, tag: i32)

lua_setuserdatatag

pub unsafe fn set_userdata_dtor(&self, tag: i32, destructor: LuaDestructor)

lua_setuserdatadtor

pub unsafe fn get_userdata_dtor(&self, tag: i32) -> Option<LuaDestructor>

lua_getuserdatadtor

pub unsafe fn set_userdata_mark(&self, tag: i32, mark: Option<LuaUserdataMark>)

lua_setuserdatamark

The callback runs during garbage collection and must not perform reentrant VM operations. Read-only host state access is permitted.

pub unsafe fn set_embedder_gc(&self, callback: Option<EmbedderGc>)

lua_setembeddergc

The callback runs during garbage collection and must not perform reentrant VM operations. When mark is present, the callback may use it to keep embedder-owned weak references alive for this cycle.

pub unsafe fn set_userdata_metatable(&self, tag: i32)

lua_setuserdatametatable

pub unsafe fn get_userdata_metatable(&self, tag: i32) -> VmErrorResult

lua_getuserdatametatable

pub unsafe fn get_userdata_name(&self, tag: i32) -> LuaString

lua_getuserdataname

pub unsafe fn get_light_userdata_name(&self, tag: i32) -> Option<LuaString>

lua_getlightuserdataname

pub unsafe fn register_userdata_direct_access( &self, tag: i32, get: LuaUserdataDirectAccess, set: LuaUserdataDirectAccess, namecall: Option<LuaUserdataDirectNamecall>, ) -> i32

lua_registeruserdatadirectaccess

pub unsafe fn register_userdata_direct_field_get( &self, tag: i32, field: &[u8], get: LuaUserdataDirectFieldGet, ) -> VmErrorResult

lua_registeruserdatadirectfieldget

pub unsafe fn set_light_userdata_name( &self, tag: i32, name: &str, ) -> VmErrorResult

lua_setlightuserdataname

impl Thread

pub unsafe fn global(&self) -> GlobalState

Returns a non-owning handle to this thread’s global VM state.

Safety

This thread and its owning VM must still be live. The returned handle does not extend the global state’s lifetime or establish a borrow of the underlying record.

impl Thread

pub unsafe fn same_vm(&self, other: impl AsRef<Thread>) -> bool

Returns whether both handles belong to the same VM.

Safety

Both threads and their owning VMs must still be live.

pub unsafe fn encode_pointer(&self, pointer: usize) -> usize

lua_encodepointer

pub unsafe fn set_pointer_encode_key(&self, a: u64, b: u64, c: u64, d: u64)

lua_setpointerencodekey

pub unsafe fn reset(&self) -> VmErrorResult

lua_resetthread

pub unsafe fn is_reset(&self) -> bool

lua_isthreadreset

pub unsafe fn status(&self) -> i32

lua_status

pub unsafe fn is_yieldable(&self) -> i32

lua_isyieldable

pub unsafe fn thread_data(&self) -> *mut ()

lua_getthreaddata

pub unsafe fn set_thread_data(&self, data: *mut ())

lua_setthreaddata

pub unsafe fn callbacks(&self) -> *mut LuaCallbacks

lua_callbacks

Returns the VM-owned callback record address. Mutating this record is only valid while the VM is quiescent, and the update must not be observable in a partially written state. The record is non-atomic and the pointer is not a cross-thread interruption mechanism.

Safety

The thread and its VM must remain live. The caller must not dereference a stale pointer or read or write the record concurrently with VM execution.

impl Thread

pub unsafe fn push_thread(&self) -> VmErrorResult<i32>

lua_pushthread

pub unsafe fn to_thread(&self, index: i32) -> Option<Thread>

lua_tothread

pub unsafe fn new_thread(&self) -> VmErrorResult<Thread>

lua_newthread

pub unsafe fn co_status(&self, thread: &Thread) -> i32

lua_costatus

Trait Implementations

impl AsRef<Thread> for Thread

fn as_ref(&self) -> &Thread

Converts this type into a shared reference of the (usually inferred) input type.

impl BufferRuntime for Thread

unsafe fn new_buffer_internal(&self, size: usize) -> VmErrorResult<Buffer>

luaB_newbuffer

unsafe fn free_buffer(&self, buffer: Buffer, page: LuaPage)

luaB_freebuffer

impl CallRuntime for Thread

unsafe fn perform_cally( &self, function: TValueCursor, n_results: i32, ) -> VmResult

luaD_performcally

unsafe fn call_int( &self, function: TValueCursor, n_results: i32, prepare_reentry: bool, ) -> VmResult

luaD_callint

unsafe fn call_internal( &self, function: TValueCursor, n_results: i32, ) -> VmResult

luaD_call

unsafe fn call_no_yield( &self, function: TValueCursor, n_results: i32, ) -> VmResult

luaD_callny

impl ClassRuntime for Thread

unsafe fn new_blank_class(&self, name: TString) -> VmErrorResult<Class>

luaR_newblankclass

unsafe fn add_class_metatable(&self, class: Class) -> VmErrorResult

luaR_addclassmetatable

unsafe fn new_class( &self, name: TString, members_to_offset: Table, offset_to_member: *mut TString, number_of_instance_members: u32, number_of_static_members: u32, ) -> VmErrorResult<Class>

luaR_newclass

unsafe fn inherit_class( &self, child: Class, parent: Class, ) -> VmErrorResult<Class>

luaR_inheritclass

unsafe fn free_class(&self, class: Class, page: LuaPage)

luaR_freeclass

unsafe fn free_object(&self, object: Object, page: LuaPage)

luaR_freeobject

unsafe fn create_object(&self) -> NativeCallResult

luaR_createobject

impl DebugRuntime for Thread

unsafe fn type_error<T>( &self, object: TValue, operation: &str, ) -> VmErrorResult<T>

luaG_typeerror

unsafe fn for_error<T>(&self, object: TValue, what: &str) -> VmErrorResult<T>

luaG_forerror

unsafe fn concat_error<T>( &self, left: TValue, right: TValue, ) -> VmErrorResult<T>

luaG_concaterror

unsafe fn arith_error<T>( &self, left: TValue, right: TValue, operation: TmEvent, ) -> VmErrorResult<T>

luaG_aritherror

unsafe fn order_error<T>( &self, left: TValue, right: TValue, operation: TmEvent, ) -> VmErrorResult<T>

luaG_ordererror

unsafe fn index_error<T>(&self, object: TValue, key: TValue) -> VmErrorResult<T>

luaG_indexerror

unsafe fn method_error<T>( &self, object: TValue, key: TString, ) -> VmErrorResult<T>

luaG_methoderror

unsafe fn missing_member_error<T>( &self, object: TValue, key: TValue, ) -> VmErrorResult<T>

luaG_missingmembererror

unsafe fn readonly_error<T>(&self) -> VmErrorResult<T>

luaG_readonlyerror

unsafe fn run_error<'a, T, F, A>(&self, format: F, args: A) -> VmErrorResult<T>

where F: AsRef<[u8]>, A: AsMut<[Arg<'a>]>,

luaG_runerror

unsafe fn push_error(&self, error: &BStr) -> VmErrorResult

luaG_pusherror

unsafe fn breakpoint_internal( &self, proto: Proto, line: i32, enable: bool, ) -> VmErrorResult

luaG_breakpoint

unsafe fn on_break(&self) -> bool

luaG_onbreak

unsafe fn is_native(&self, level: i32) -> i32

luaG_isnative

unsafe fn has_native(&self, level: i32) -> i32

luaG_hasnative

impl Eq for Thread

impl ErrorRuntime for Thread

unsafe fn set_error_object(&self, error_code: i32, old_top: TValueCursor)

luaD_seterrorobj

impl From<&Thread> for GcObject

fn from(value: &Thread) -> Self

Converts to this type from the input type.

impl From<Thread> for GcObject

fn from(value: Thread) -> Self

Converts to this type from the input type.

impl FunctionRuntime for Thread

unsafe fn find_upvalue(&self, level: TValue) -> VmErrorResult<UpVal>

luaF_findupval

unsafe fn close(&self, level: TValue)

luaF_close

unsafe fn close_upvalue(&self, upvalue: UpVal, dead: bool)

luaF_closeupval

unsafe fn new_proto(&self) -> VmErrorResult<Proto>

luaF_newproto

unsafe fn new_lua_closure( &self, element_count: i32, environment: Option<Table>, proto: Proto, ) -> VmErrorResult<Closure>

luaF_newLclosure

unsafe fn new_native_closure( &self, element_count: i32, environment: Option<Table>, ) -> VmErrorResult<Closure>

luaF_newCclosure

unsafe fn free_proto(&self, proto: Proto, page: LuaPage)

luaF_freeproto

unsafe fn free_closure(&self, closure: Closure, page: LuaPage)

luaF_freeclosure

unsafe fn free_upvalue(&self, upvalue: UpVal, page: LuaPage)

luaF_freeupval

unsafe fn record_hit( &self, caller: Closure, target: Closure, slot_id: u32, ) -> bool

luaF_recordhit

impl GcBarrier for Thread

unsafe fn barrier_value(&self, object: GcObject, value: TValue)

luaC_barrier

unsafe fn object_barrier(&self, object: GcObject, child: GcObject)

luaC_objbarrier

unsafe fn thread_barrier(&self)

luaC_threadbarrier

unsafe fn barrier_forward(&self, object: GcObject, value: GcObject)

luaC_barrierf

unsafe fn barrier_table(&self, table: Table, value: GcObject)

luaC_barriertable

unsafe fn barrier_back(&self, object: GcObject, gc_list: *mut *mut RawGcObject)

luaC_barrierback

unsafe fn upvalue_closed(&self, upvalue: UpVal)

luaC_upvalclosed

impl GcRuntime for Thread

unsafe fn free_all(&self)

luaC_freeall

unsafe fn needs_gc(&self) -> bool

luaC_needsGC

unsafe fn check_gc(&self) -> VmErrorResult

luaC_checkGC

unsafe fn step(&self, assist: bool) -> VmErrorResult<usize>

luaC_step

unsafe fn full_gc(&self)

luaC_fullgc

unsafe fn validate(&self)

luaC_validate

unsafe fn dump( &self, file: *mut (), category_name: Option<&mut dyn GcCategoryNamer>, )

luaC_dump

unsafe fn enum_heap(&self, context: *mut (), node: GcHeapNode, edge: GcHeapEdge)

luaC_enumheap

unsafe fn allocation_rate(&self) -> i64

luaC_allocationrate

impl MemoryRuntime for Thread

unsafe fn new_raw(&self, layout: Layout, memcat: u8) -> VmErrorResult<*mut u8>

luaM_new_

unsafe fn new_gco_(&self, size: usize, memcat: u8) -> VmErrorResult<GcObject>

luaM_newgco_

unsafe fn free_raw(&self, block: *mut u8, old_layout: Layout, memcat: u8)

luaM_free_

unsafe fn free_gco( &self, block: GcObject, old_size: usize, memcat: u8, page: LuaPage, )

luaM_freegco_

unsafe fn realloc_raw( &self, block: *mut u8, old_layout: Layout, new_layout: Layout, memcat: u8, ) -> VmErrorResult<*mut u8>

luaM_realloc_

unsafe fn too_big<T>(&self) -> VmErrorResult<T>

luaM_toobig

unsafe fn visit_gco( &self, context: *mut (), visitor: unsafe fn(*mut (), LuaPage, GcObject) -> bool, )

luaM_visitgco

unsafe fn new_array<T>(&self, count: usize, memcat: u8) -> VmErrorResult<*mut T>

unsafe fn free_array<T>(&self, block: *mut T, count: usize, memcat: u8)

unsafe fn realloc_array<T>( &self, block: *mut T, old_count: usize, new_count: usize, memcat: u8, ) -> VmErrorResult<*mut T>

unsafe fn array_layout<T>(&self, count: usize) -> VmErrorResult<Layout>

impl MetamethodRuntime for Thread

unsafe fn init(&self) -> VmErrorResult

luaT_init

unsafe fn fast_tm( &self, events: Option<Table>, event: TmEvent, ) -> Option<TValue>

fasttm

unsafe fn fast_notm(&self, events: Option<Table>, event: TmEvent) -> bool

fastnotm

unsafe fn get_tm_by_obj(&self, object: TValue, event: TmEvent) -> Option<TValue>

luaT_gettmbyobj

unsafe fn obj_type_name_str(&self, object: TValue) -> TString

luaT_objtypenamestr

unsafe fn obj_type_name(&self, object: TValue) -> LuaString

luaT_objtypename

impl PartialEq for Thread

fn eq(&self, other: &Thread) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl ProtectedCall for Thread

unsafe fn raw_run_protected<T>( &self, function: Pfunc<T>, userdata: &mut T, ) -> VmResult

luaD_rawrunprotected

unsafe fn protected_call_internal<T>( &self, function: Pfunc<T>, userdata: &mut T, old_top: isize, error_function: isize, ) -> VmResult

luaD_pcall

impl RawHandle for Thread

type Raw = RawLuaState

Raw VM record addressed by this handle.

fn as_ptr(&self) -> *mut RawLuaState

Returns the record address without dereferencing it.

impl RawStackAccess for Thread

unsafe fn to_object(&self, index: i32) -> Option<TValue>

luaA_toobject

unsafe fn push_value_internal(&self, value: TValue) -> VmErrorResult

luaA_pushvalue

unsafe fn push_class(&self, class: Class) -> VmErrorResult

luaA_pushclass

unsafe fn push_table(&self, table: Table) -> VmErrorResult

impl StringFormatting for Thread

unsafe fn push_vfstring_internal<'a, A>( &self, format: &str, args: A, ) -> VmErrorResult<LuaString>

where A: AsMut<[Arg<'a>]>,

luaO_pushvfstring

unsafe fn push_fstring_internal<'a, A>( &self, format: &str, args: A, ) -> VmErrorResult<LuaString>

where A: AsMut<[Arg<'a>]>,

luaO_pushfstring

impl StringRuntime for Thread

unsafe fn resize(&self, new_size: i32) -> VmErrorResult

luaS_resize

unsafe fn intern_string(&self, bytes: &BStr) -> VmErrorResult<TString>

luaS_newlstr

unsafe fn free_string(&self, string: TString, page: LuaPage)

luaS_free

unsafe fn update_atom(&self, string: TString)

luaS_updateatom

unsafe fn buffer_start(&self, size: usize) -> VmErrorResult<TString>

luaS_bufstart

unsafe fn buffer_finish(&self, string: TString) -> VmErrorResult<TString>

luaS_buffinish

impl StructuralPartialEq for Thread

impl TableRuntime for Thread

unsafe fn set_num(&self, table: Table, key: i32) -> VmErrorResult<TValue>

luaH_setnum

unsafe fn set_str( &self, table: Table, key: TString, ) -> VmErrorResult<LuaNodeCursor>

luaH_setstr

unsafe fn setp( &self, table: Table, key: *mut (), tag: i32, ) -> VmErrorResult<TValue>

luaH_setp

unsafe fn set(&self, table: Table, key: TValue) -> VmErrorResult<TValue>

luaH_set

unsafe fn set_slot( &self, table: Table, slot: TValue, key: TValue, ) -> VmErrorResult<TValue>

luaH_setslot

unsafe fn new_key(&self, table: Table, key: TValue) -> VmErrorResult<TValue>

luaH_newkey

unsafe fn next_internal( &self, table: Table, key: TValueCursor, ) -> VmErrorResult<i32>

luaH_next

unsafe fn new_table_internal( &self, n_array: i32, n_hash: i32, ) -> VmErrorResult<Table>

luaH_new

unsafe fn resize_array(&self, table: Table, n_array: i32) -> VmErrorResult

luaH_resizearray

unsafe fn resize_hash(&self, table: Table, n_hash: i32) -> VmErrorResult

luaH_resizehash

unsafe fn free_table(&self, table: Table, page: LuaPage)

luaH_free

unsafe fn clone_table_internal(&self, table: Table) -> VmErrorResult<Table>

luaH_clone

impl ThreadLifecycle for Thread

unsafe fn new_thread_internal(&self) -> VmErrorResult<Thread>

luaE_newthread

unsafe fn free_thread(&self, thread: &Thread, page: LuaPage)

luaE_freethread

unsafe fn allocation_size(&self) -> usize

thread-owned allocation size

impl ThreadStack for Thread

unsafe fn check_stack_internal(&self, needed: i32) -> VmErrorResult

luaD_checkstack

unsafe fn check_stack_for_new_ci(&self, needed: i32) -> VmErrorResult

luaD_checkstackfornewci

unsafe fn get_grown_stack_size(&self, needed: i32) -> i32

getgrownstacksize

unsafe fn stack_limit_reached(&self, needed: i32) -> bool

stacklimitreached

unsafe fn save_stack(&self, pointer: TValueCursor) -> isize

savestack

unsafe fn restore_stack(&self, offset: isize) -> TValueCursor

restorestack

unsafe fn save_ci(&self, pointer: CallInfoCursor) -> isize

saveci

unsafe fn restore_ci(&self, offset: isize) -> CallInfoCursor

restoreci

unsafe fn expand_stack_limit(&self, pointer: TValueCursor)

expandstacklimit

unsafe fn realloc_stack(&self, new_size: i32, for_new_ci: bool) -> VmErrorResult

luaD_reallocstack

unsafe fn realloc_ci(&self, new_size: i32) -> VmErrorResult

luaD_reallocCI

unsafe fn grow_stack(&self, needed: i32) -> VmErrorResult

luaD_growstack

unsafe fn grow_ci(&self) -> VmErrorResult<CallInfoCursor>

luaD_growCI

unsafe fn incr_ci(&self) -> VmErrorResult<CallInfoCursor>

incr_ci

unsafe fn check_c_stack(&self) -> VmErrorResult

luaD_checkCstack

impl ThreadState for Thread

unsafe fn from_raw(raw: NonNull<RawLuaState>) -> Self

unsafe fn current_call_info_cursor(&self) -> CallInfoCursor

unsafe fn base_call_info_cursor(&self) -> CallInfoCursor

unsafe fn set_current_call_info(&self, call_info: CallInfoCursor)

unsafe fn stack(&self) -> TValueCursor

unsafe fn stack_base(&self) -> TValueCursor

unsafe fn stack_top(&self) -> TValueCursor

unsafe fn stack_last(&self) -> TValueCursor

unsafe fn set_stack(&self, stack: TValueCursor)

unsafe fn set_stack_base(&self, base: TValueCursor)

unsafe fn set_stack_top(&self, top: TValueCursor)

unsafe fn open_upvalue(&self) -> Option<UpVal>

unsafe fn set_open_upvalue(&self, upvalue: Option<UpVal>)

unsafe fn gc_list(&self) -> Option<GcObject>

unsafe fn set_gc_list(&self, gc_list: Option<GcObject>)

unsafe fn name_call(&self) -> Option<TString>

unsafe fn set_name_call(&self, name_call: Option<TString>)

unsafe fn cached_slot(&self) -> i32

unsafe fn set_cached_slot(&self, cached_slot: i32)

unsafe fn globals(&self) -> Table

unsafe fn set_globals(&self, globals: Table)

unsafe fn increment_native_call_depth(&self)

unsafe fn decrement_native_call_depth(&self)

unsafe fn increment_base_native_call_depth(&self)

unsafe fn decrement_base_native_call_depth(&self)

unsafe fn current_call_info(&self) -> CallInfo

unsafe fn base_call_info(&self) -> CallInfo

unsafe fn restore_call_frame( &self, call_info: CallInfoCursor, top: TValueCursor, )

unsafe fn current_function(&self) -> Closure

unsafe fn current_env(&self) -> Table

impl TypedUserdataAccess for Thread

unsafe fn typed_userdata(&self, userdata: Userdata) -> Option<TypedUserdata>

unsafe fn typed_userdata_at(&self, index: i32) -> Option<TypedUserdata>

unsafe fn push_typed_userdata<T: 'static>( &self, value: T, registration: &UserdataTypeRegistration, ) -> VmErrorResult

unsafe fn typed_userdata_value(&self, userdata: TypedUserdata) -> TValue

unsafe fn set_typed_userdata_value( &self, userdata: TypedUserdata, value: TValue, )

unsafe fn take_typed_userdata<T: 'static>( &self, userdata: TypedUserdata, ) -> Result<T, TypedUserdataError>

unsafe fn destroy_typed_userdata( &self, userdata: TypedUserdata, ) -> Result<(), TypedUserdataError>

impl UserdataRuntime for Thread

unsafe fn new_userdata_internal( &self, payload_len: usize, tag: i32, ) -> VmErrorResult<Userdata>

luaU_newudata

unsafe fn free_userdata(&self, userdata: Userdata, page: LuaPage)

luaU_freeudata

unsafe fn new_userdata_tagged_internal( &self, size: usize, tag: i32, ) -> VmErrorResult<*mut ()>

impl UserdataTypeRegistryAccess for Thread

unsafe fn userdata_type<T: 'static>(&self) -> Option<UserdataTypeRegistration>

unsafe fn retire_userdata_type<T: 'static>(&self)

unsafe fn register_userdata_type<T: 'static>( &self, metatable_index: i32, ) -> VmErrorResult<UserdataTypeRegistration>

impl VmCallFrame for Thread

unsafe fn try_func_tm(&self, function: TValueCursor) -> VmResult

luaV_tryfuncTM

unsafe fn pre_call( &self, function: TValueCursor, n_results: i32, ) -> VmResult<PreCallResult>

luau_precall

unsafe fn pos_call(&self, first: TValueCursor)

luau_poscall

unsafe fn call_hook<F>(&self, hook: F, userdata: *mut ()) -> VmResult

where F: FnOnce(&Thread, &mut LuaDebug) -> VmResult,

luau_callhook

impl VmConversions for Thread

unsafe fn to_number_internal( &self, value: TValue, result: TValue, ) -> Option<TValue>

luaV_tonumber

unsafe fn to_vector_internal(&self, value: TValue) -> Option<[f32; 3]>

luaV_tovector

unsafe fn to_string_internal(&self, value: TValue) -> VmErrorResult<i32>

luaV_tostring

impl VmExecution for Thread

unsafe fn execute(&self) -> VmResult

luau_execute

unsafe fn finish_op(&self) -> VmResult

luau_finishop

impl VmOperations for Thread

unsafe fn less_than_internal( &self, left: TValue, right: TValue, ) -> VmResult<i32>

luaV_lessthan

unsafe fn less_equal(&self, left: TValue, right: TValue) -> VmResult<i32>

luaV_lessequal

unsafe fn equal_value(&self, left: TValue, right: TValue) -> VmResult<i32>

luaV_equalval

unsafe fn do_arith_impl( &self, result: TValueCursor, left: TValue, right: TValue, op: TmEvent, ) -> VmResult

luaV_doarithimpl

unsafe fn do_len(&self, result: TValueCursor, value: TValue) -> VmResult

luaV_dolen

unsafe fn get_table_internal( &self, table: TValue, key: TValue, value: TValueCursor, ) -> VmResult

luaV_gettable

unsafe fn set_table_internal( &self, table: TValue, key: TValue, value: TValue, ) -> VmResult

luaV_settable

unsafe fn concat_internal(&self, total: i32, last: i32) -> VmResult

luaV_concat

unsafe fn get_import( &self, env: Table, constants: TValueCursor, target: TValueCursor, id: u32, propagate_nil: bool, ) -> VmResult

luaV_getimport

unsafe fn prepare_forn( &self, limit: TValueCursor, step: TValueCursor, index: TValueCursor, ) -> VmResult

luaV_prepareFORN

unsafe fn call_tm(&self, n_params: i32, result: i32) -> VmResult

luaV_callTM