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

COLIBNAME :: "coroutine"

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

DBLIBNAME :: "debug"

ERRERR :: Status.ERRERR

ERRFILE :: Status.ERRFILE

ERRMEM :: Status.ERRMEM

ERRRUN :: Status.ERRRUN

ERRSYNTAX :: Status.ERRSYNTAX

EXTRASPACE :: 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 :: "_G"

HOOKCALL :: HookEvent.CALL

HOOKCOUNT :: HookEvent.COUNT

HOOKLINE :: HookEvent.LINE

HOOKRET :: HookEvent.RET

HOOKTAILCALL :: HookEvent.TAILCALL

IDSIZE :: 60

IOLIBNAME :: "io"

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

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

LOADED_TABLE :: "_LOADED"

LOADLIBNAME :: "package"

LUA_SHARED :: #config(LUA_SHARED, false)

MASKCALL :: HookMask{.CALL}

MASKCOUNT :: HookMask{.COUNT}

MASKLINE :: HookMask{.LINE}

MASKRET :: HookMask{.RET}

MATHLIBNAME :: "math"

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

MAXSTACK :: 1000000

MINSTACK :: 20

MULTRET :: -1

NOREF :: -2

NUMTYPES :: 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 :: "os"

PRELOAD_TABLE :: "_PRELOAD"

REFNIL :: -1

REGISTRYINDEX :: -MAXSTACK - 1000

RELEASE :: VERSION + "." + VERSION_RELEASE

RIDX_GLOBALS :: 2

RIDX_LAST :: RIDX_GLOBALS

RIDX_MAINTHREAD :: 1

SIGNATURE :: "\x1bLua"

STRLIBNAME :: "string"

TABLIBNAME :: "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 :: "utf8"

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

VERSION_MAJOR :: "5"

VERSION_MINOR :: "4"

VERSION_NUM :: 504

VERSION_RELEASE :: "2"

VERSION_RELEASE_NUM :: VERSION_NUM * 100 + 0

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

YIELD :: Status.YIELD

LUA_SHARED :: #config(LUA_SHARED, false)

Alloc :: Alloc

ArithOp :: ArithOp

CFunction :: CFunction

CompareOp :: CompareOp

Debug :: Debug

GCWhat :: GCWhat

Hook :: Hook

HookEvent :: HookEvent

HookMask :: distinct HookMask

Integer :: distinct Integer

KContext :: distinct KContext

KFunction :: KFunction

L_Buffer :: L_Buffer

L_Reg :: L_Reg

Number :: distinct Number

Reader :: Reader

State :: State

Status :: Status

Type :: Type

Unsigned :: distinct Unsigned

WarnFunction :: WarnFunction

Writer :: Writer

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

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

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

@(link_name="lua_callk")

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 ---

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) ---

@(link_name="luaL_checklstring")

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 ---

@(link_name="luaL_checkversion_")

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 ---

@(link_name="luaL_loadbufferx")

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

@(link_name="luaL_loadfilex")

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) -> $$deferred_return {…}

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

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

@(link_name="luaL_optlstring")

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 ---

@(link_name="luaL_tolstring")

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) ---

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 ---

@(link_name="lua_pcallk")

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 :: proc "c" (L: ^State) ---

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 :: proc "c" (L: ^State, s: cstring) -> cstring ---

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: 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) ---

@(link_name="lua_tointegerx")

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

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

@(link_name="lua_tonumberx")

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) ---

@(link_name="lua_yieldk")

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

ident: [^]u8