package vendor:lua/5.4

Source

Alloc :: proc "c" (ud: rawptr, ptr: rawptr, osize, nsize: uint) -> rawptr

ArithOp :: enum i32 {
	ADD  = 0,  // ORDER TM, ORDER OP
	SUB  = 1, 
	MUL  = 2, 
	MOD  = 3, 
	POW  = 4, 
	DIV  = 5, 
	IDIV = 6, 
	BAND = 7, 
	BOR  = 8, 
	BXOR = 9, 
	SHL  = 10, 
	SHR  = 11, 
	UNM  = 12, 
	BNOT = 13, 
}

CFunction :: proc "c" (L: ^State) -> i32

CompareOp :: enum i32 {
	EQ = 0, 
	LT = 1, 
	LE = 2, 
}

Debug :: struct {
	event:           HookEvent,
	name:            cstring,
	// (n) 
	namewhat:        cstring,
	// (n) 'global', 'local', 'field', 'method' 
	what:            cstring,
	// (S) 'Lua', 'C', 'main', 'tail' 
	source:          cstring,
	// (S) 
	srclen:          uint,
	// (S) 
	currentline:     i32,
	// (l) 
	linedefined:     i32,
	// (S) 
	lastlinedefined: i32,
	// (S) 
	nups:            u8,
	// (u) number of upvalues 
	nparams:         u8,
	// (u) number of parameters 
	isvararg:        bool,
	// (u) 
	istailcall:      bool,
	// (t) 
	ftransfer:       u16,
	// (r) index of first value transferred 
	ntransfer:       u16,
	// (r) number of transferred values 
	short_src:       [60]u8 `fmt:"s"`,
	// private part 
	i_ci:            rawptr,
}

GCWhat :: enum i32 {
	STOP       = 0, 
	RESTART    = 1, 
	COLLECT    = 2, 
	COUNT      = 3, 
	COUNTB     = 4, 
	STEP       = 5, 
	SETPAUSE   = 6, 
	SETSTEPMUL = 7, 
	ISRUNNING  = 9, 
	GEN        = 10, 
	INC        = 11, 
}

Hook :: proc "c" (L: ^State, ar: ^Debug)

HookEvent :: enum i32 {
	CALL     = 0, 
	RET      = 1, 
	LINE     = 2, 
	COUNT    = 3, 
	TAILCALL = 4, 
}

HookMask :: distinct bit_set[HookEvent; i32]

Integer :: distinct i64

KContext :: distinct int

KFunction :: proc "c" (L: ^State, status: i32, ctx: KContext) -> i32

L_Buffer :: struct {
	b:    [^]u8,
	// buffer address 
	size: uint,
	// buffer size 
	n:    uint,
	// number of characters in buffer 
	L:    ^State,
	init: struct #raw_union {
		n: Number,
		u: f64,
		s: rawptr,
		i: Integer,
		l: i32,
		b: [1024]u8,
	},
}

L_Reg :: struct {
	name: cstring,
	func: CFunction,
}

Number :: distinct f64

Reader :: proc "c" (L: ^State, ud: rawptr, sz: ^uint) -> cstring

State :: struct {}

Status :: enum i32 {
	OK        = 0, 
	YIELD     = 1, 
	ERRRUN    = 2, 
	ERRSYNTAX = 3, 
	ERRMEM    = 4, 
	ERRERR    = 5, 
	ERRFILE   = 6, 
}

Type :: enum i32 {
	NONE          = -1, 
	NIL           = 0, 
	BOOLEAN       = 1, 
	LIGHTUSERDATA = 2, 
	NUMBER        = 3, 
	STRING        = 4, 
	TABLE         = 5, 
	FUNCTION      = 6, 
	USERDATA      = 7, 
	THREAD        = 8, 
}

Unsigned :: distinct u64

WarnFunction :: proc "c" (ud: rawptr, msg: rawptr, tocont: i32)

Writer :: proc "c" (L: ^State, p: rawptr, sz: ^uint, ud: rawptr) -> i32

AUTHORS: string : "R. Ierusalimschy, L. H. de Figueiredo, W. Celes"

COLIBNAME: string : "coroutine"

COPYRIGHT: string : RELEASE + "  Copyright (C) 1994-2020 Lua.org, PUC-Rio"

DBLIBNAME: string : "debug"

ERRERR :: Status.ERRERR

ERRFILE :: Status.ERRFILE

ERRMEM :: Status.ERRMEM

ERRRUN :: Status.ERRRUN

ERRSYNTAX :: Status.ERRSYNTAX

EXTRASPACE: int : size_of(rawptr)

GCCOLLECT :: GCWhat.COLLECT

GCCOUNT :: GCWhat.COUNT

GCCOUNTB :: GCWhat.COUNTB

GCGEN :: GCWhat.GEN

GCINC :: GCWhat.INC

GCISRUNNING :: GCWhat.ISRUNNING

GCRESTART :: GCWhat.RESTART

GCSETPAUSE :: GCWhat.SETPAUSE

GCSETSTEPMUL :: GCWhat.SETSTEPMUL

GCSTEP :: GCWhat.STEP

GCSTOP :: GCWhat.STOP

GNAME: string : "_G"

HOOKCALL :: HookEvent.CALL

HOOKCOUNT :: HookEvent.COUNT

HOOKLINE :: HookEvent.LINE

HOOKRET :: HookEvent.RET

HOOKTAILCALL :: HookEvent.TAILCALL

IDSIZE: int : 60

IOLIBNAME: string : "io"

LOADED_TABLE: string : "_LOADED"

LOADLIBNAME: string : "package"

LUA_SHARED: bool : #config(LUA_SHARED, false)

L_BUFFERSIZE: i32 : c.int(16 * size_of(rawptr) * size_of(Number))

L_NUMSIZES: int : size_of(Integer) * 16 + size_of(Number)

MASKCALL :: HookMask{.CALL}

MASKCOUNT :: HookMask{.COUNT}

MASKLINE :: HookMask{.LINE}

MASKRET :: HookMask{.RET}

MATHLIBNAME: string : "math"

MAXALIGNVAL: int : max(align_of(Number), align_of(f64), align_of(rawptr), align_of(Integer), align_of(c.long))

MAXSTACK: int : 1000000

MINSTACK: int : 20

MULTRET: int : -1

NOREF: int : -2

NUMTYPES: int : 9

OK :: Status.OK

OPADD :: ArithOp.ADD

OPBAND :: ArithOp.BAND

OPBNOT :: ArithOp.BNOT

OPBOR :: ArithOp.BOR

OPBXOR :: ArithOp.BXOR

OPDIV :: ArithOp.DIV

OPEQ :: CompareOp.EQ

OPIDIV :: ArithOp.IDIV

OPLE :: CompareOp.LE

OPLT :: CompareOp.LT

OPMOD :: ArithOp.MOD

OPMUL :: ArithOp.MUL

OPPOW :: ArithOp.POW

OPSHL :: ArithOp.SHL

OPSHR :: ArithOp.SHR

OPSUB :: ArithOp.SUB

OPUNM :: ArithOp.UNM

OSLIBNAME: string : "os"

PRELOAD_TABLE: string : "_PRELOAD"

REFNIL: int : -1

REGISTRYINDEX: int : -MAXSTACK - 1000

RELEASE: string : VERSION + "." + VERSION_RELEASE

RIDX_GLOBALS: int : 2

RIDX_LAST: int : RIDX_GLOBALS

RIDX_MAINTHREAD: int : 1

SIGNATURE: string : "\x1bLua"

STRLIBNAME: string : "string"

TABLIBNAME: string : "table"

TBOOLEAN :: Type.BOOLEAN

TFUNCTION :: Type.FUNCTION

TLIGHTUSERDATA :: Type.LIGHTUSERDATA

TNIL :: Type.NIL

TNONE :: Type.NONE

TNUMBER :: Type.NUMBER

TSTRING :: Type.STRING

TTABLE :: Type.TABLE

TTHREAD :: Type.THREAD

TUSERDATA :: Type.USERDATA

UTF8LIBNAME: string : "utf8"

VERSION: string : "Lua " + VERSION_MAJOR + "." + VERSION_MINOR

VERSION_MAJOR: string : "5"

VERSION_MINOR: string : "4"

VERSION_NUM: int : 504

VERSION_RELEASE: string : "2"

VERSION_RELEASE_NUM: int : VERSION_NUM * 100 + 0

VERSUFFIX: string : "_" + VERSION_MAJOR + "_" + VERSION_MINOR

YIELD :: Status.YIELD

ident: [^]u8

L_addchar :: proc "c" (B: ^L_Buffer, c: u8) {…}

L_addgsub :: proc "c" (b: ^L_Buffer, s, p, r: cstring) ---

L_addlstring :: proc "c" (B: ^L_Buffer, s: cstring, l: uint) ---

L_addsize :: proc "c" (B: ^L_Buffer, s: uint) -> uint {…}

L_addstring :: proc "c" (B: ^L_Buffer, s: cstring) ---

L_addvalue :: proc "c" (B: ^L_Buffer) ---

L_argcheck :: proc "c" (L: ^State, cond: bool, arg: i32, extramsg: cstring) {…}

L_argerror :: proc "c" (L: ^State, arg: i32, extramsg: cstring) -> i32 ---

L_argexpected :: proc "c" (L: ^State, cond: bool, arg: i32, tname: cstring) {…}

L_buffaddr :: proc "c" (bf: ^L_Buffer) -> [^]u8 {…}

L_buffinit :: proc "c" (L: ^State, B: ^L_Buffer) ---

L_buffinitsize :: proc "c" (L: ^State, B: ^L_Buffer, sz: uint) -> [^]u8 ---

L_bufflen :: proc "c" (bf: ^L_Buffer) -> uint {…}

L_buffsub :: proc "c" (B: ^L_Buffer, s: uint) -> uint {…}

L_callmeta :: proc "c" (L: ^State, obj: i32, e: cstring) -> i32 ---

L_checkany :: proc "c" (L: ^State, arg: i32) ---

L_checkinteger :: proc "c" (L: ^State, arg: i32) -> Integer ---

L_checknumber :: proc "c" (L: ^State, arg: i32) -> Number ---

L_checkoption :: proc "c" (L: ^State, arg: i32, def: cstring, lst: [^]cstring) -> i32 ---

L_checkstack :: proc "c" (L: ^State, sz: i32, msg: cstring) ---

L_checkstring :: proc "c" (L: ^State, arg: i32, l: ^uint = nil) -> cstring ---

L_checktype :: proc "c" (L: ^State, arg: i32, t: i32) ---

L_checkudata :: proc "c" (L: ^State, ud: i32, tname: cstring) -> rawptr ---

L_checkversion :: proc "c" (L: ^State, ver: Number = VERSION_NUM, sz: uint = L_NUMSIZES) ---

L_dofile :: proc "c" (L: ^State, s: cstring) -> i32 {…}

L_dostring :: proc "c" (L: ^State, s: cstring) -> i32 {…}

L_error :: proc "c" (L: ^State, fmt: cstring, .. args: ..any) -> Status ---

L_execresult :: proc "c" (L: ^State, stat: i32) -> i32 ---

L_fileresult :: proc "c" (L: ^State, stat: i32, fname: cstring) -> i32 ---

L_getmetafield :: proc "c" (L: ^State, obj: i32, e: cstring) -> i32 ---

L_getmetatable :: proc "c" (L: ^State, n: cstring) -> i32 {…}

L_getsubtable :: proc "c" (L: ^State, idx: i32, fname: cstring) -> i32 ---

L_gsub :: proc "c" (L: ^State, s, p, r: cstring) -> cstring ---

L_len :: proc "c" (L: ^State, idx: i32) -> Integer ---

L_loadbuffer :: proc "c" (L: ^State, buff: [^]u8, sz: uint, name: cstring, mode: cstring = nil) -> Status ---

L_loadfile :: proc "c" (L: ^State, filename: cstring, mode: cstring = nil) -> Status ---

L_loadstring :: proc "c" (L: ^State, s: cstring) -> Status ---

L_newlib :: proc(L: ^State, l: []L_Reg) {…}

L_newlibtable :: proc "c" (L: ^State, l: []L_Reg) {…}

L_newmetatable :: proc "c" (L: ^State, tname: cstring) -> i32 ---

L_newstate :: proc "c" () -> ^State ---

L_openlibs :: proc "c" (L: ^State) ---

L_opt :: proc "c" (L: ^State, f: $F, n: i32, d: $T) -> $T {…}

L_optinteger :: proc "c" (L: ^State, arg: i32, def: Integer) -> Integer ---

L_optnumber :: proc "c" (L: ^State, arg: i32, def: Number) -> Number ---

L_optstring :: proc "c" (L: ^State, arg: i32, def: cstring, l: ^uint = nil) -> cstring ---

L_prepbuffer :: proc "c" (B: ^L_Buffer) -> [^]u8 {…}

L_prepbuffsize :: proc "c" (B: ^L_Buffer, sz: uint) -> [^]u8 ---

L_pushresult :: proc "c" (B: ^L_Buffer) ---

L_pushresultsize :: proc "c" (B: ^L_Buffer, sz: uint) ---

L_ref :: proc "c" (L: ^State, t: i32) -> i32 ---

L_requiref :: proc "c" (L: ^State, modname: cstring, openf: CFunction, glb: i32) ---

L_setfuncs :: proc "c" (L: ^State, l: [^]L_Reg, nup: i32) ---

L_setmetatable :: proc "c" (L: ^State, tname: cstring) ---

L_testudata :: proc "c" (L: ^State, ud: i32, tname: cstring) -> rawptr ---

L_tostring :: proc "c" (L: ^State, idx: i32, len: ^uint = nil) -> cstring ---

L_traceback :: proc "c" (L: ^State, L1: ^State, msg: cstring, level: i32) ---

L_typeerror :: proc "c" (L: ^State, arg: i32, tname: cstring) -> i32 ---

L_typename :: proc "c" (L: ^State, i: i32) -> cstring {…}

L_unref :: proc "c" (L: ^State, t: i32, ref: i32) ---

L_where :: proc "c" (L: ^State, lvl: i32) ---

absindex :: proc "c" (L: ^State, idx: i32) -> i32 ---

arith :: proc "c" (L: ^State, op: ArithOp) ---

atpanic :: proc "c" (L: ^State, panicf: CFunction) -> CFunction ---

call :: proc "c" (L: ^State, nargs, nresults: i32, ctx: KContext = 0, k: KFunction = nil) ---

checkstack :: proc "c" (L: ^State, n: i32) -> i32 ---

close :: proc "c" (L: ^State) ---

compare :: proc "c" (L: ^State, idx1, idx2: i32, op: CompareOp) -> b32 ---

concat :: proc "c" (L: ^State, n: i32) ---

copy :: proc "c" (L: ^State, fromidx, toidx: i32) ---

createtable :: proc "c" (L: ^State, narr, nrec: i32) ---

dump :: proc "c" (L: ^State, writer: Writer, data: rawptr, strip: b32) -> Status ---

error :: proc "c" (L: ^State) -> Status ---

gc :: proc "c" (L: ^State, what: GCWhat, .. args: ..any) -> i32 ---

getallocf :: proc "c" (L: State, ud: ^rawptr) -> Alloc ---

getextraspace :: proc "c" (L: ^State) -> rawptr {…}

getfield :: proc "c" (L: ^State, idx: i32, k: cstring) -> i32 ---

getglobal :: proc "c" (L: ^State, name: cstring) -> i32 ---

gethook :: proc "c" (L: ^State) -> Hook ---

gethookcount :: proc "c" (L: ^State) -> i32 ---

gethookmask :: proc "c" (L: ^State) -> HookMask ---

geti :: proc "c" (L: ^State, idx: i32, n: Integer) -> i32 ---

getinfo :: proc "c" (L: ^State, what: cstring, ar: ^Debug) -> i32 ---

getiuservalue :: proc "c" (L: ^State, idx: i32, n: i32) -> i32 ---

getlocal :: proc "c" (L: ^State, ar: ^Debug, n: i32) -> cstring ---

getmetatable :: proc "c" (L: ^State, objindex: i32) -> i32 ---

getstack :: proc "c" (L: ^State, level: i32, ar: ^Debug) -> i32 ---

gettable :: proc "c" (L: ^State, idx: i32) -> i32 ---

gettop :: proc "c" (L: ^State) -> i32 ---

getupvalue :: proc "c" (L: ^State, funcindex: i32, n: i32) -> cstring ---

getuservalue :: proc "c" (L: ^State, idx: i32) -> i32 {…}

insert :: proc "c" (L: ^State, idx: i32) {…}

isboolean :: proc "c" (L: ^State, n: i32) -> bool {…}

iscfunction :: proc "c" (L: ^State, idx: i32) -> b32 ---

isfunction :: proc "c" (L: ^State, n: i32) -> bool {…}

isinteger :: proc "c" (L: ^State, idx: i32) -> b32 ---

islightuserdata :: proc "c" (L: ^State, n: i32) -> bool {…}

isnil :: proc "c" (L: ^State, n: i32) -> bool {…}

isnone :: proc "c" (L: ^State, n: i32) -> bool {…}

isnoneornil :: proc "c" (L: ^State, n: i32) -> bool {…}

isnumber :: proc "c" (L: ^State, idx: i32) -> b32 ---

isstring :: proc "c" (L: ^State, idx: i32) -> b32 ---

istable :: proc "c" (L: ^State, n: i32) -> bool {…}

isthread :: proc "c" (L: ^State, n: i32) -> bool {…}

isuserdata :: proc "c" (L: ^State, idx: i32) -> b32 ---

isyieldable :: proc "c" (L: ^State) -> b32 ---

len :: proc "c" (L: ^State, idx: i32) ---

load :: proc "c" (L: ^State, reader: Reader, dt: rawptr, chunkname, mode: cstring) -> Status ---

newstate :: proc "c" (f: Alloc, ud: rawptr) -> ^State ---

newtable :: proc "c" (L: ^State) {…}

newthread :: proc "c" (L: ^State) -> ^State ---

newuserdata :: proc "c" (L: ^State, s: uint) -> rawptr {…}

newuserdatauv :: proc "c" (L: ^State, sz: uint, nuvalue: i32) -> rawptr ---

next :: proc "c" (L: ^State, idx: i32) -> i32 ---

open_base :: proc "c" (L: ^State) -> i32 ---

open_coroutine :: proc "c" (L: ^State) -> i32 ---

open_debug :: proc "c" (L: ^State) -> i32 ---

open_io :: proc "c" (L: ^State) -> i32 ---

open_math :: proc "c" (L: ^State) -> i32 ---

open_os :: proc "c" (L: ^State) -> i32 ---

open_package :: proc "c" (L: ^State) -> i32 ---

open_string :: proc "c" (L: ^State) -> i32 ---

open_table :: proc "c" (L: ^State) -> i32 ---

open_utf8 :: proc "c" (L: ^State) -> i32 ---

pcall :: proc "c" (
	L:               ^State, 
	nargs, nresults: i32, 
	errfunc:         i32, 
	ctx:             KContext = 0, 
	k:               KFunction = nil, 
) -> i32 ---

pop :: proc "c" (L: ^State, n: i32) {…}

pushboolean :: proc "c" (L: ^State, b: b32) ---

pushcclosure :: proc "c" (L: ^State, fn: CFunction, n: i32) ---

pushcfunction :: proc "c" (L: ^State, f: CFunction) {…}

pushfail :: pushnil

pushfstring :: proc "c" (L: ^State, fmt: cstring, .. args: ..any) -> cstring ---

pushglobaltable :: proc "c" (L: ^State) {…}

pushinteger :: proc "c" (L: ^State, n: Integer) ---

pushlightuserdata :: proc "c" (L: ^State, p: rawptr) ---

pushliteral :: pushstring

pushlstring :: proc "c" (L: ^State, s: cstring, len: uint) -> cstring ---

pushnil :: proc "c" (L: ^State) ---

pushnumber :: proc "c" (L: ^State, n: Number) ---

pushstring :: proc "c" (L: ^State, s: cstring) -> cstring ---

pushthread :: proc "c" (L: ^State) -> Status ---

pushvalue :: proc "c" (L: ^State, idx: i32) ---

pushvfstring :: proc "c" (L: ^State, fmt: cstring, argp: c.va_list) -> cstring ---

rawequal :: proc "c" (L: ^State, idx1, idx2: i32) -> b32 ---

rawget :: proc "c" (L: ^State, idx: i32) -> i32 ---

rawgeti :: proc "c" (L: ^State, idx: i32, n: Integer) -> i32 ---

rawgetp :: proc "c" (L: ^State, idx: i32, p: rawptr) -> i32 ---

rawlen :: proc "c" (L: ^State, idx: i32) -> Unsigned ---

rawset :: proc "c" (L: ^State, idx: i32) ---

rawseti :: proc "c" (L: ^State, idx: i32, n: Integer) ---

rawsetp :: proc "c" (L: ^State, idx: i32, p: rawptr) ---

register :: proc "c" (L: ^State, n: cstring, f: CFunction) {…}

remove :: proc "c" (L: ^State, idx: i32) {…}

replace :: proc "c" (L: ^State, idx: i32) {…}

resetthread :: proc "c" (L: ^State) -> Status ---

resume :: proc "c" (L: ^State, from: ^State, narg: i32, nres: ^i32) -> Status ---

rotate :: proc "c" (L: ^State, idx: i32, n: i32) ---

setallocf :: proc "c" (L: ^State, f: Alloc, ud: rawptr) ---

setcstacklimit :: proc "c" (L: ^State, limit: u32) -> i32 ---

setfield :: proc "c" (L: ^State, idx: i32, k: cstring) ---

setglobal :: proc "c" (L: ^State, name: cstring) ---

sethook :: proc "c" (L: ^State, func: Hook, mask: HookMask, count: i32) ---

seti :: proc "c" (L: ^State, idx: i32, n: Integer) ---

setiuservalue :: proc "c" (L: ^State, idx: i32, n: i32) -> i32 ---

setlocal :: proc "c" (L: ^State, ar: ^Debug, n: i32) -> cstring ---

setmetatable :: proc "c" (L: ^State, objindex: i32) -> i32 ---

settable :: proc "c" (L: ^State, idx: i32) ---

settop :: proc "c" (L: ^State, idx: i32) ---

setupvalue :: proc "c" (L: ^State, funcindex: i32, n: i32) -> cstring ---

setuservalue :: proc "c" (L: ^State, idx: i32) -> i32 {…}

setwarnf :: proc "c" (L: ^State, f: WarnFunction, ud: rawptr) ---

status :: proc "c" (L: ^State) -> Status ---

stringtonumber :: proc "c" (L: ^State, s: cstring) -> uint ---

toboolean :: proc "c" (L: ^State, idx: i32) -> b32 ---

tocfunction :: proc "c" (L: ^State, idx: i32) -> CFunction ---

toclose :: proc "c" (L: ^State, idx: i32) ---

tointeger :: proc "c" (L: ^State, idx: i32, isnum: ^b32 = nil) -> Integer ---

tolstring :: proc "c" (L: ^State, idx: i32, len: ^uint) -> cstring ---

tonumber :: proc "c" (L: ^State, idx: i32, isnum: ^b32 = nil) -> Number ---

topointer :: proc "c" (L: ^State, idx: i32) -> rawptr ---

tostring :: proc "c" (L: ^State, i: i32) -> cstring {…}

tothread :: proc "c" (L: ^State, idx: i32) -> ^State ---

touserdata :: proc "c" (L: ^State, idx: i32) -> rawptr ---

type :: proc "c" (L: ^State, idx: i32) -> Type ---

typename :: proc "c" (L: ^State, tp: Type) -> cstring ---

upvalueid :: proc "c" (L: ^State, fidx, n: i32) -> rawptr ---

upvaluejoin :: proc "c" (L: ^State, fidx1, n1, fidx2, n2: i32) ---

version :: proc "c" (L: ^State) -> Number ---

warning :: proc "c" (L: ^State, msg: string, tocont: b32) ---

xmove :: proc "c" (from, to: ^State, n: i32) ---

yield :: proc "c" (L: ^State, nresults: i32, ctx: KContext = 0, k: KFunction = nil) -> Status ---