pub const SQTrue: u32 = 1;
pub const SQFalse: u32 = 0;
pub const SQ_ALIGNMENT: u32 = 8;
pub const MAX_CHAR: u32 = 255;
pub const SQUIRREL_VERSION_NUMBER: u32 = 310;
pub const SQ_VMSTATE_IDLE: u32 = 0;
pub const SQ_VMSTATE_RUNNING: u32 = 1;
pub const SQ_VMSTATE_SUSPENDED: u32 = 2;
pub const SQUIRREL_EOB: u32 = 0;
pub const SQ_BYTECODE_STREAM_TAG: u32 = 64250;
pub const SQOBJECT_REF_COUNTED: u32 = 134217728;
pub const SQOBJECT_NUMERIC: u32 = 67108864;
pub const SQOBJECT_DELEGABLE: u32 = 33554432;
pub const SQOBJECT_CANBEFALSE: u32 = 16777216;
pub const SQ_MATCHTYPEMASKSTRING: i32 = -99999;
pub const _RT_MASK: u32 = 16777215;
pub const _RT_NULL: u32 = 1;
pub const _RT_INTEGER: u32 = 2;
pub const _RT_FLOAT: u32 = 4;
pub const _RT_BOOL: u32 = 8;
pub const _RT_STRING: u32 = 16;
pub const _RT_TABLE: u32 = 32;
pub const _RT_ARRAY: u32 = 64;
pub const _RT_USERDATA: u32 = 128;
pub const _RT_CLOSURE: u32 = 256;
pub const _RT_NATIVECLOSURE: u32 = 512;
pub const _RT_GENERATOR: u32 = 1024;
pub const _RT_USERPOINTER: u32 = 2048;
pub const _RT_THREAD: u32 = 4096;
pub const _RT_FUNCPROTO: u32 = 8192;
pub const _RT_CLASS: u32 = 16384;
pub const _RT_INSTANCE: u32 = 32768;
pub const _RT_WEAKREF: u32 = 65536;
pub const _RT_OUTER: u32 = 131072;
pub const SQ_OK: u32 = 0;
pub const SQ_ERROR: i32 = -1;
pub const SQ_SEEK_CUR: u32 = 0;
pub const SQ_SEEK_END: u32 = 1;
pub const SQ_SEEK_SET: u32 = 2;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQVM {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQTable {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQArray {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQString {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQClosure {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQGenerator {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQNativeClosure {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQUserData {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQFunctionProto {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQRefCounted {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQClass {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQInstance {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQDelegable {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQOuter {
_unused: [u8; 0],
}
pub type SQInteger = ::std::os::raw::c_longlong;
pub type SQUnsignedInteger = ::std::os::raw::c_ulonglong;
pub type SQHash = ::std::os::raw::c_ulonglong;
pub type SQInt32 = ::std::os::raw::c_int;
pub type SQUnsignedInteger32 = ::std::os::raw::c_uint;
pub type SQFloat = f32;
pub type SQRawObjectVal = ::std::os::raw::c_longlong;
pub type SQUserPointer = *mut ::std::os::raw::c_void;
pub type SQBool = SQUnsignedInteger;
pub type SQRESULT = SQInteger;
pub type SQChar = ::std::os::raw::c_char;
pub const tagSQObjectType_OT_NULL: tagSQObjectType = 16777217;
pub const tagSQObjectType_OT_INTEGER: tagSQObjectType = 83886082;
pub const tagSQObjectType_OT_FLOAT: tagSQObjectType = 83886084;
pub const tagSQObjectType_OT_BOOL: tagSQObjectType = 16777224;
pub const tagSQObjectType_OT_STRING: tagSQObjectType = 134217744;
pub const tagSQObjectType_OT_TABLE: tagSQObjectType = 167772192;
pub const tagSQObjectType_OT_ARRAY: tagSQObjectType = 134217792;
pub const tagSQObjectType_OT_USERDATA: tagSQObjectType = 167772288;
pub const tagSQObjectType_OT_CLOSURE: tagSQObjectType = 134217984;
pub const tagSQObjectType_OT_NATIVECLOSURE: tagSQObjectType = 134218240;
pub const tagSQObjectType_OT_GENERATOR: tagSQObjectType = 134218752;
pub const tagSQObjectType_OT_USERPOINTER: tagSQObjectType = 2048;
pub const tagSQObjectType_OT_THREAD: tagSQObjectType = 134221824;
pub const tagSQObjectType_OT_FUNCPROTO: tagSQObjectType = 134225920;
pub const tagSQObjectType_OT_CLASS: tagSQObjectType = 134234112;
pub const tagSQObjectType_OT_INSTANCE: tagSQObjectType = 167804928;
pub const tagSQObjectType_OT_WEAKREF: tagSQObjectType = 134283264;
pub const tagSQObjectType_OT_OUTER: tagSQObjectType = 134348800;
pub type tagSQObjectType = u32;
pub use self::tagSQObjectType as SQObjectType;
#[repr(C)]
#[derive(Copy, Clone)]
pub union tagSQObjectValue {
pub pTable: *mut SQTable,
pub pArray: *mut SQArray,
pub pClosure: *mut SQClosure,
pub pOuter: *mut SQOuter,
pub pGenerator: *mut SQGenerator,
pub pNativeClosure: *mut SQNativeClosure,
pub pString: *mut SQString,
pub pUserData: *mut SQUserData,
pub nInteger: SQInteger,
pub fFloat: SQFloat,
pub pUserPointer: SQUserPointer,
pub pFunctionProto: *mut SQFunctionProto,
pub pRefCounted: *mut SQRefCounted,
pub pDelegable: *mut SQDelegable,
pub pThread: *mut SQVM,
pub pClass: *mut SQClass,
pub pInstance: *mut SQInstance,
pub pWeakRef: *mut SQWeakRef,
pub raw: SQRawObjectVal,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_tagSQObjectValue() {
assert_eq!(
::std::mem::size_of::<tagSQObjectValue>(),
8usize,
concat!("Size of: ", stringify!(tagSQObjectValue))
);
assert_eq!(
::std::mem::align_of::<tagSQObjectValue>(),
8usize,
concat!("Alignment of ", stringify!(tagSQObjectValue))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).pTable as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(pTable)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).pArray as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(pArray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).pClosure as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(pClosure)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).pOuter as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(pOuter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).pGenerator as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(pGenerator)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).pNativeClosure as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(pNativeClosure)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).pString as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(pString)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).pUserData as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(pUserData)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).nInteger as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(nInteger)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).fFloat as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(fFloat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).pUserPointer as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(pUserPointer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).pFunctionProto as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(pFunctionProto)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).pRefCounted as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(pRefCounted)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).pDelegable as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(pDelegable)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).pThread as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(pThread)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).pClass as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(pClass)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).pInstance as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(pInstance)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).pWeakRef as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(pWeakRef)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObjectValue>())).raw as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObjectValue),
"::",
stringify!(raw)
)
);
}
pub type SQObjectValue = tagSQObjectValue;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct tagSQObject {
pub _type: SQObjectType,
pub _unVal: SQObjectValue,
}
#[test]
fn bindgen_test_layout_tagSQObject() {
assert_eq!(
::std::mem::size_of::<tagSQObject>(),
16usize,
concat!("Size of: ", stringify!(tagSQObject))
);
assert_eq!(
::std::mem::align_of::<tagSQObject>(),
8usize,
concat!("Alignment of ", stringify!(tagSQObject))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObject>()))._type as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQObject),
"::",
stringify!(_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQObject>()))._unVal as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(tagSQObject),
"::",
stringify!(_unVal)
)
);
}
pub type SQObject = tagSQObject;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct tagSQMemberHandle {
pub _static: SQBool,
pub _index: SQInteger,
}
#[test]
fn bindgen_test_layout_tagSQMemberHandle() {
assert_eq!(
::std::mem::size_of::<tagSQMemberHandle>(),
16usize,
concat!("Size of: ", stringify!(tagSQMemberHandle))
);
assert_eq!(
::std::mem::align_of::<tagSQMemberHandle>(),
8usize,
concat!("Alignment of ", stringify!(tagSQMemberHandle))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQMemberHandle>()))._static as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQMemberHandle),
"::",
stringify!(_static)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQMemberHandle>()))._index as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(tagSQMemberHandle),
"::",
stringify!(_index)
)
);
}
pub type SQMemberHandle = tagSQMemberHandle;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct tagSQStackInfos {
pub funcname: *const SQChar,
pub source: *const SQChar,
pub line: SQInteger,
}
#[test]
fn bindgen_test_layout_tagSQStackInfos() {
assert_eq!(
::std::mem::size_of::<tagSQStackInfos>(),
24usize,
concat!("Size of: ", stringify!(tagSQStackInfos))
);
assert_eq!(
::std::mem::align_of::<tagSQStackInfos>(),
8usize,
concat!("Alignment of ", stringify!(tagSQStackInfos))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQStackInfos>())).funcname as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQStackInfos),
"::",
stringify!(funcname)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQStackInfos>())).source as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(tagSQStackInfos),
"::",
stringify!(source)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQStackInfos>())).line as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(tagSQStackInfos),
"::",
stringify!(line)
)
);
}
pub type SQStackInfos = tagSQStackInfos;
pub type HSQUIRRELVM = *mut SQVM;
pub type HSQOBJECT = SQObject;
pub type HSQMEMBERHANDLE = SQMemberHandle;
pub type SQFUNCTION = ::std::option::Option<unsafe extern "C" fn(arg1: HSQUIRRELVM) -> SQInteger>;
pub type SQRELEASEHOOK =
::std::option::Option<unsafe extern "C" fn(arg1: SQUserPointer, size: SQInteger) -> SQInteger>;
pub type SQCOMPILERERROR = ::std::option::Option<
unsafe extern "C" fn(
arg1: HSQUIRRELVM,
arg2: *const SQChar,
arg3: *const SQChar,
arg4: SQInteger,
arg5: SQInteger,
),
>;
pub type SQPRINTFUNCTION =
::std::option::Option<unsafe extern "C" fn(arg1: HSQUIRRELVM, arg2: *const SQChar, ...)>;
pub type SQDEBUGHOOK = ::std::option::Option<
unsafe extern "C" fn(
arg1: HSQUIRRELVM,
arg2: SQInteger,
arg3: *const SQChar,
arg4: SQInteger,
arg5: *const SQChar,
),
>;
pub type SQWRITEFUNC = ::std::option::Option<
unsafe extern "C" fn(arg1: SQUserPointer, arg2: SQUserPointer, arg3: SQInteger) -> SQInteger,
>;
pub type SQREADFUNC = ::std::option::Option<
unsafe extern "C" fn(arg1: SQUserPointer, arg2: SQUserPointer, arg3: SQInteger) -> SQInteger,
>;
pub type SQLEXREADFUNC =
::std::option::Option<unsafe extern "C" fn(arg1: SQUserPointer) -> SQInteger>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct tagSQRegFunction {
pub name: *const SQChar,
pub f: SQFUNCTION,
pub nparamscheck: SQInteger,
pub typemask: *const SQChar,
}
#[test]
fn bindgen_test_layout_tagSQRegFunction() {
assert_eq!(
::std::mem::size_of::<tagSQRegFunction>(),
32usize,
concat!("Size of: ", stringify!(tagSQRegFunction))
);
assert_eq!(
::std::mem::align_of::<tagSQRegFunction>(),
8usize,
concat!("Alignment of ", stringify!(tagSQRegFunction))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQRegFunction>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQRegFunction),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQRegFunction>())).f as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(tagSQRegFunction),
"::",
stringify!(f)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQRegFunction>())).nparamscheck as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(tagSQRegFunction),
"::",
stringify!(nparamscheck)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQRegFunction>())).typemask as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(tagSQRegFunction),
"::",
stringify!(typemask)
)
);
}
pub type SQRegFunction = tagSQRegFunction;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct tagSQFunctionInfo {
pub funcid: SQUserPointer,
pub name: *const SQChar,
pub source: *const SQChar,
pub line: SQInteger,
}
#[test]
fn bindgen_test_layout_tagSQFunctionInfo() {
assert_eq!(
::std::mem::size_of::<tagSQFunctionInfo>(),
32usize,
concat!("Size of: ", stringify!(tagSQFunctionInfo))
);
assert_eq!(
::std::mem::align_of::<tagSQFunctionInfo>(),
8usize,
concat!("Alignment of ", stringify!(tagSQFunctionInfo))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQFunctionInfo>())).funcid as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagSQFunctionInfo),
"::",
stringify!(funcid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQFunctionInfo>())).name as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(tagSQFunctionInfo),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQFunctionInfo>())).source as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(tagSQFunctionInfo),
"::",
stringify!(source)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagSQFunctionInfo>())).line as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(tagSQFunctionInfo),
"::",
stringify!(line)
)
);
}
pub type SQFunctionInfo = tagSQFunctionInfo;
extern "C" {
pub fn sq_open(initialstacksize: SQInteger) -> HSQUIRRELVM;
}
extern "C" {
pub fn sq_newthread(friendvm: HSQUIRRELVM, initialstacksize: SQInteger) -> HSQUIRRELVM;
}
extern "C" {
pub fn sq_seterrorhandler(v: HSQUIRRELVM);
}
extern "C" {
pub fn sq_close(v: HSQUIRRELVM);
}
extern "C" {
pub fn sq_setforeignptr(v: HSQUIRRELVM, p: SQUserPointer);
}
extern "C" {
pub fn sq_getforeignptr(v: HSQUIRRELVM) -> SQUserPointer;
}
extern "C" {
pub fn sq_setsharedforeignptr(v: HSQUIRRELVM, p: SQUserPointer);
}
extern "C" {
pub fn sq_getsharedforeignptr(v: HSQUIRRELVM) -> SQUserPointer;
}
extern "C" {
pub fn sq_setvmreleasehook(v: HSQUIRRELVM, hook: SQRELEASEHOOK);
}
extern "C" {
pub fn sq_getvmreleasehook(v: HSQUIRRELVM) -> SQRELEASEHOOK;
}
extern "C" {
pub fn sq_setsharedreleasehook(v: HSQUIRRELVM, hook: SQRELEASEHOOK);
}
extern "C" {
pub fn sq_getsharedreleasehook(v: HSQUIRRELVM) -> SQRELEASEHOOK;
}
extern "C" {
pub fn sq_setprintfunc(v: HSQUIRRELVM, printfunc: SQPRINTFUNCTION, errfunc: SQPRINTFUNCTION);
}
extern "C" {
pub fn sq_getprintfunc(v: HSQUIRRELVM) -> SQPRINTFUNCTION;
}
extern "C" {
pub fn sq_geterrorfunc(v: HSQUIRRELVM) -> SQPRINTFUNCTION;
}
extern "C" {
pub fn sq_suspendvm(v: HSQUIRRELVM) -> SQRESULT;
}
extern "C" {
pub fn sq_wakeupvm(
v: HSQUIRRELVM,
resumedret: SQBool,
retval: SQBool,
raiseerror: SQBool,
throwerror: SQBool,
) -> SQRESULT;
}
extern "C" {
pub fn sq_getvmstate(v: HSQUIRRELVM) -> SQInteger;
}
extern "C" {
pub fn sq_getversion() -> SQInteger;
}
extern "C" {
pub fn sq_compile(
v: HSQUIRRELVM,
read: SQLEXREADFUNC,
p: SQUserPointer,
sourcename: *const SQChar,
raiseerror: SQBool,
) -> SQRESULT;
}
extern "C" {
pub fn sq_compilebuffer(
v: HSQUIRRELVM,
s: *const SQChar,
size: SQInteger,
sourcename: *const SQChar,
raiseerror: SQBool,
) -> SQRESULT;
}
extern "C" {
pub fn sq_enabledebuginfo(v: HSQUIRRELVM, enable: SQBool);
}
extern "C" {
pub fn sq_notifyallexceptions(v: HSQUIRRELVM, enable: SQBool);
}
extern "C" {
pub fn sq_setcompilererrorhandler(v: HSQUIRRELVM, f: SQCOMPILERERROR);
}
extern "C" {
pub fn sq_push(v: HSQUIRRELVM, idx: SQInteger);
}
extern "C" {
pub fn sq_pop(v: HSQUIRRELVM, nelemstopop: SQInteger);
}
extern "C" {
pub fn sq_poptop(v: HSQUIRRELVM);
}
extern "C" {
pub fn sq_remove(v: HSQUIRRELVM, idx: SQInteger);
}
extern "C" {
pub fn sq_gettop(v: HSQUIRRELVM) -> SQInteger;
}
extern "C" {
pub fn sq_settop(v: HSQUIRRELVM, newtop: SQInteger);
}
extern "C" {
pub fn sq_reservestack(v: HSQUIRRELVM, nsize: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_cmp(v: HSQUIRRELVM) -> SQInteger;
}
extern "C" {
pub fn sq_move(dest: HSQUIRRELVM, src: HSQUIRRELVM, idx: SQInteger);
}
extern "C" {
pub fn sq_newuserdata(v: HSQUIRRELVM, size: SQUnsignedInteger) -> SQUserPointer;
}
extern "C" {
pub fn sq_newtable(v: HSQUIRRELVM);
}
extern "C" {
pub fn sq_newtableex(v: HSQUIRRELVM, initialcapacity: SQInteger);
}
extern "C" {
pub fn sq_newarray(v: HSQUIRRELVM, size: SQInteger);
}
extern "C" {
pub fn sq_newclosure(v: HSQUIRRELVM, func: SQFUNCTION, nfreevars: SQUnsignedInteger);
}
extern "C" {
pub fn sq_setparamscheck(
v: HSQUIRRELVM,
nparamscheck: SQInteger,
typemask: *const SQChar,
) -> SQRESULT;
}
extern "C" {
pub fn sq_bindenv(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_setclosureroot(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_getclosureroot(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_pushstring(v: HSQUIRRELVM, s: *const SQChar, len: SQInteger);
}
extern "C" {
pub fn sq_pushfloat(v: HSQUIRRELVM, f: SQFloat);
}
extern "C" {
pub fn sq_pushinteger(v: HSQUIRRELVM, n: SQInteger);
}
extern "C" {
pub fn sq_pushbool(v: HSQUIRRELVM, b: SQBool);
}
extern "C" {
pub fn sq_pushuserpointer(v: HSQUIRRELVM, p: SQUserPointer);
}
extern "C" {
pub fn sq_pushnull(v: HSQUIRRELVM);
}
extern "C" {
pub fn sq_pushthread(v: HSQUIRRELVM, thread: HSQUIRRELVM);
}
extern "C" {
pub fn sq_gettype(v: HSQUIRRELVM, idx: SQInteger) -> SQObjectType;
}
extern "C" {
pub fn sq_typeof(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_getsize(v: HSQUIRRELVM, idx: SQInteger) -> SQInteger;
}
extern "C" {
pub fn sq_gethash(v: HSQUIRRELVM, idx: SQInteger) -> SQHash;
}
extern "C" {
pub fn sq_getbase(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_instanceof(v: HSQUIRRELVM) -> SQBool;
}
extern "C" {
pub fn sq_tostring(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_tobool(v: HSQUIRRELVM, idx: SQInteger, b: *mut SQBool);
}
extern "C" {
pub fn sq_getstringandsize(
v: HSQUIRRELVM,
idx: SQInteger,
c: *mut *const SQChar,
size: *mut SQInteger,
) -> SQRESULT;
}
extern "C" {
pub fn sq_getstring(v: HSQUIRRELVM, idx: SQInteger, c: *mut *const SQChar) -> SQRESULT;
}
extern "C" {
pub fn sq_getinteger(v: HSQUIRRELVM, idx: SQInteger, i: *mut SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_getfloat(v: HSQUIRRELVM, idx: SQInteger, f: *mut SQFloat) -> SQRESULT;
}
extern "C" {
pub fn sq_getbool(v: HSQUIRRELVM, idx: SQInteger, b: *mut SQBool) -> SQRESULT;
}
extern "C" {
pub fn sq_getthread(v: HSQUIRRELVM, idx: SQInteger, thread: *mut HSQUIRRELVM) -> SQRESULT;
}
extern "C" {
pub fn sq_getuserpointer(v: HSQUIRRELVM, idx: SQInteger, p: *mut SQUserPointer) -> SQRESULT;
}
extern "C" {
pub fn sq_getuserdata(
v: HSQUIRRELVM,
idx: SQInteger,
p: *mut SQUserPointer,
typetag: *mut SQUserPointer,
) -> SQRESULT;
}
extern "C" {
pub fn sq_settypetag(v: HSQUIRRELVM, idx: SQInteger, typetag: SQUserPointer) -> SQRESULT;
}
extern "C" {
pub fn sq_gettypetag(v: HSQUIRRELVM, idx: SQInteger, typetag: *mut SQUserPointer) -> SQRESULT;
}
extern "C" {
pub fn sq_setreleasehook(v: HSQUIRRELVM, idx: SQInteger, hook: SQRELEASEHOOK);
}
extern "C" {
pub fn sq_getreleasehook(v: HSQUIRRELVM, idx: SQInteger) -> SQRELEASEHOOK;
}
extern "C" {
pub fn sq_getscratchpad(v: HSQUIRRELVM, minsize: SQInteger) -> *mut SQChar;
}
extern "C" {
pub fn sq_getfunctioninfo(
v: HSQUIRRELVM,
level: SQInteger,
fi: *mut SQFunctionInfo,
) -> SQRESULT;
}
extern "C" {
pub fn sq_getclosureinfo(
v: HSQUIRRELVM,
idx: SQInteger,
nparams: *mut SQInteger,
nfreevars: *mut SQInteger,
) -> SQRESULT;
}
extern "C" {
pub fn sq_getclosurename(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_setnativeclosurename(v: HSQUIRRELVM, idx: SQInteger, name: *const SQChar)
-> SQRESULT;
}
extern "C" {
pub fn sq_setinstanceup(v: HSQUIRRELVM, idx: SQInteger, p: SQUserPointer) -> SQRESULT;
}
extern "C" {
pub fn sq_getinstanceup(
v: HSQUIRRELVM,
idx: SQInteger,
p: *mut SQUserPointer,
typetag: SQUserPointer,
) -> SQRESULT;
}
extern "C" {
pub fn sq_setclassudsize(v: HSQUIRRELVM, idx: SQInteger, udsize: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_newclass(v: HSQUIRRELVM, hasbase: SQBool) -> SQRESULT;
}
extern "C" {
pub fn sq_createinstance(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_setattributes(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_getattributes(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_getclass(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_weakref(v: HSQUIRRELVM, idx: SQInteger);
}
extern "C" {
pub fn sq_getdefaultdelegate(v: HSQUIRRELVM, t: SQObjectType) -> SQRESULT;
}
extern "C" {
pub fn sq_getmemberhandle(
v: HSQUIRRELVM,
idx: SQInteger,
handle: *mut HSQMEMBERHANDLE,
) -> SQRESULT;
}
extern "C" {
pub fn sq_getbyhandle(
v: HSQUIRRELVM,
idx: SQInteger,
handle: *const HSQMEMBERHANDLE,
) -> SQRESULT;
}
extern "C" {
pub fn sq_setbyhandle(
v: HSQUIRRELVM,
idx: SQInteger,
handle: *const HSQMEMBERHANDLE,
) -> SQRESULT;
}
extern "C" {
pub fn sq_pushroottable(v: HSQUIRRELVM);
}
extern "C" {
pub fn sq_pushregistrytable(v: HSQUIRRELVM);
}
extern "C" {
pub fn sq_pushconsttable(v: HSQUIRRELVM);
}
extern "C" {
pub fn sq_setroottable(v: HSQUIRRELVM) -> SQRESULT;
}
extern "C" {
pub fn sq_setconsttable(v: HSQUIRRELVM) -> SQRESULT;
}
extern "C" {
pub fn sq_newslot(v: HSQUIRRELVM, idx: SQInteger, bstatic: SQBool) -> SQRESULT;
}
extern "C" {
pub fn sq_deleteslot(v: HSQUIRRELVM, idx: SQInteger, pushval: SQBool) -> SQRESULT;
}
extern "C" {
pub fn sq_set(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_get(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_rawget(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_rawset(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_rawdeleteslot(v: HSQUIRRELVM, idx: SQInteger, pushval: SQBool) -> SQRESULT;
}
extern "C" {
pub fn sq_newmember(v: HSQUIRRELVM, idx: SQInteger, bstatic: SQBool) -> SQRESULT;
}
extern "C" {
pub fn sq_rawnewmember(v: HSQUIRRELVM, idx: SQInteger, bstatic: SQBool) -> SQRESULT;
}
extern "C" {
pub fn sq_arrayappend(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_arraypop(v: HSQUIRRELVM, idx: SQInteger, pushval: SQBool) -> SQRESULT;
}
extern "C" {
pub fn sq_arrayresize(v: HSQUIRRELVM, idx: SQInteger, newsize: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_arrayreverse(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_arrayremove(v: HSQUIRRELVM, idx: SQInteger, itemidx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_arrayinsert(v: HSQUIRRELVM, idx: SQInteger, destpos: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_setdelegate(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_getdelegate(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_clone(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_setfreevariable(v: HSQUIRRELVM, idx: SQInteger, nval: SQUnsignedInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_next(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_getweakrefval(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_clear(v: HSQUIRRELVM, idx: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_call(
v: HSQUIRRELVM,
params: SQInteger,
retval: SQBool,
raiseerror: SQBool,
) -> SQRESULT;
}
extern "C" {
pub fn sq_resume(v: HSQUIRRELVM, retval: SQBool, raiseerror: SQBool) -> SQRESULT;
}
extern "C" {
pub fn sq_getlocal(
v: HSQUIRRELVM,
level: SQUnsignedInteger,
idx: SQUnsignedInteger,
) -> *const SQChar;
}
extern "C" {
pub fn sq_getcallee(v: HSQUIRRELVM) -> SQRESULT;
}
extern "C" {
pub fn sq_getfreevariable(
v: HSQUIRRELVM,
idx: SQInteger,
nval: SQUnsignedInteger,
) -> *const SQChar;
}
extern "C" {
pub fn sq_throwerror(v: HSQUIRRELVM, err: *const SQChar) -> SQRESULT;
}
extern "C" {
pub fn sq_throwobject(v: HSQUIRRELVM) -> SQRESULT;
}
extern "C" {
pub fn sq_reseterror(v: HSQUIRRELVM);
}
extern "C" {
pub fn sq_getlasterror(v: HSQUIRRELVM);
}
extern "C" {
pub fn sq_tailcall(v: HSQUIRRELVM, nparams: SQInteger) -> SQRESULT;
}
extern "C" {
pub fn sq_getstackobj(v: HSQUIRRELVM, idx: SQInteger, po: *mut HSQOBJECT) -> SQRESULT;
}
extern "C" {
pub fn sq_pushobject(v: HSQUIRRELVM, obj: HSQOBJECT);
}
extern "C" {
pub fn sq_addref(v: HSQUIRRELVM, po: *mut HSQOBJECT);
}
extern "C" {
pub fn sq_release(v: HSQUIRRELVM, po: *mut HSQOBJECT) -> SQBool;
}
extern "C" {
pub fn sq_getrefcount(v: HSQUIRRELVM, po: *mut HSQOBJECT) -> SQUnsignedInteger;
}
extern "C" {
pub fn sq_resetobject(po: *mut HSQOBJECT);
}
extern "C" {
pub fn sq_objtostring(o: *const HSQOBJECT) -> *const SQChar;
}
extern "C" {
pub fn sq_objtobool(o: *const HSQOBJECT) -> SQBool;
}
extern "C" {
pub fn sq_objtointeger(o: *const HSQOBJECT) -> SQInteger;
}
extern "C" {
pub fn sq_objtofloat(o: *const HSQOBJECT) -> SQFloat;
}
extern "C" {
pub fn sq_objtouserpointer(o: *const HSQOBJECT) -> SQUserPointer;
}
extern "C" {
pub fn sq_getobjtypetag(o: *const HSQOBJECT, typetag: *mut SQUserPointer) -> SQRESULT;
}
extern "C" {
pub fn sq_getvmrefcount(v: HSQUIRRELVM, po: *const HSQOBJECT) -> SQUnsignedInteger;
}
extern "C" {
pub fn sq_collectgarbage(v: HSQUIRRELVM) -> SQInteger;
}
extern "C" {
pub fn sq_resurrectunreachable(v: HSQUIRRELVM) -> SQRESULT;
}
extern "C" {
pub fn sq_writeclosure(vm: HSQUIRRELVM, writef: SQWRITEFUNC, up: SQUserPointer) -> SQRESULT;
}
extern "C" {
pub fn sq_readclosure(vm: HSQUIRRELVM, readf: SQREADFUNC, up: SQUserPointer) -> SQRESULT;
}
extern "C" {
pub fn sq_malloc(size: SQUnsignedInteger) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn sq_realloc(
p: *mut ::std::os::raw::c_void,
oldsize: SQUnsignedInteger,
newsize: SQUnsignedInteger,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn sq_free(p: *mut ::std::os::raw::c_void, size: SQUnsignedInteger);
}
extern "C" {
pub fn sq_stackinfos(v: HSQUIRRELVM, level: SQInteger, si: *mut SQStackInfos) -> SQRESULT;
}
extern "C" {
pub fn sq_setdebughook(v: HSQUIRRELVM);
}
extern "C" {
pub fn sq_setnativedebughook(v: HSQUIRRELVM, hook: SQDEBUGHOOK);
}
extern "C" {
pub fn sqstd_seterrorhandlers(v: HSQUIRRELVM);
}
extern "C" {
pub fn sqstd_printcallstack(v: HSQUIRRELVM);
}
extern "C" {
pub fn sqstd_throwerrorf(v: HSQUIRRELVM, err: *const SQChar, ...) -> SQRESULT;
}
extern "C" {
pub fn sqstd_createblob(v: HSQUIRRELVM, size: SQInteger) -> SQUserPointer;
}
extern "C" {
pub fn sqstd_getblob(v: HSQUIRRELVM, idx: SQInteger, ptr: *mut SQUserPointer) -> SQRESULT;
}
extern "C" {
pub fn sqstd_getblobsize(v: HSQUIRRELVM, idx: SQInteger) -> SQInteger;
}
extern "C" {
pub fn sqstd_register_bloblib(v: HSQUIRRELVM) -> SQRESULT;
}
pub type SQFILE = *mut ::std::os::raw::c_void;
extern "C" {
pub fn sqstd_fopen(arg1: *const SQChar, arg2: *const SQChar) -> SQFILE;
}
extern "C" {
pub fn sqstd_fread(
arg1: SQUserPointer,
arg2: SQInteger,
arg3: SQInteger,
arg4: SQFILE,
) -> SQInteger;
}
extern "C" {
pub fn sqstd_fwrite(
arg1: SQUserPointer,
arg2: SQInteger,
arg3: SQInteger,
arg4: SQFILE,
) -> SQInteger;
}
extern "C" {
pub fn sqstd_fseek(arg1: SQFILE, arg2: SQInteger, arg3: SQInteger) -> SQInteger;
}
extern "C" {
pub fn sqstd_ftell(arg1: SQFILE) -> SQInteger;
}
extern "C" {
pub fn sqstd_fflush(arg1: SQFILE) -> SQInteger;
}
extern "C" {
pub fn sqstd_fclose(arg1: SQFILE) -> SQInteger;
}
extern "C" {
pub fn sqstd_feof(arg1: SQFILE) -> SQInteger;
}
extern "C" {
pub fn sqstd_createfile(v: HSQUIRRELVM, file: SQFILE, own: SQBool) -> SQRESULT;
}
extern "C" {
pub fn sqstd_getfile(v: HSQUIRRELVM, idx: SQInteger, file: *mut SQFILE) -> SQRESULT;
}
extern "C" {
pub fn sqstd_loadfile(v: HSQUIRRELVM, filename: *const SQChar, printerror: SQBool) -> SQRESULT;
}
extern "C" {
pub fn sqstd_dofile(
v: HSQUIRRELVM,
filename: *const SQChar,
retval: SQBool,
printerror: SQBool,
) -> SQRESULT;
}
extern "C" {
pub fn sqstd_writeclosuretofile(v: HSQUIRRELVM, filename: *const SQChar) -> SQRESULT;
}
extern "C" {
pub fn sqstd_register_iolib(v: HSQUIRRELVM) -> SQRESULT;
}
extern "C" {
pub fn sqstd_register_mathlib(v: HSQUIRRELVM) -> SQRESULT;
}
pub type SQRexBool = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQRex {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQRexMatch {
pub begin: *const SQChar,
pub len: SQInteger,
}
#[test]
fn bindgen_test_layout_SQRexMatch() {
assert_eq!(
::std::mem::size_of::<SQRexMatch>(),
16usize,
concat!("Size of: ", stringify!(SQRexMatch))
);
assert_eq!(
::std::mem::align_of::<SQRexMatch>(),
8usize,
concat!("Alignment of ", stringify!(SQRexMatch))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<SQRexMatch>())).begin as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(SQRexMatch),
"::",
stringify!(begin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<SQRexMatch>())).len as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(SQRexMatch),
"::",
stringify!(len)
)
);
}
extern "C" {
pub fn sqstd_rex_compile(pattern: *const SQChar, error: *mut *const SQChar) -> *mut SQRex;
}
extern "C" {
pub fn sqstd_rex_free(exp: *mut SQRex);
}
extern "C" {
pub fn sqstd_rex_match(exp: *mut SQRex, text: *const SQChar) -> SQBool;
}
extern "C" {
pub fn sqstd_rex_search(
exp: *mut SQRex,
text: *const SQChar,
out_begin: *mut *const SQChar,
out_end: *mut *const SQChar,
) -> SQBool;
}
extern "C" {
pub fn sqstd_rex_searchrange(
exp: *mut SQRex,
text_begin: *const SQChar,
text_end: *const SQChar,
out_begin: *mut *const SQChar,
out_end: *mut *const SQChar,
) -> SQBool;
}
extern "C" {
pub fn sqstd_rex_getsubexpcount(exp: *mut SQRex) -> SQInteger;
}
extern "C" {
pub fn sqstd_rex_getsubexp(exp: *mut SQRex, n: SQInteger, subexp: *mut SQRexMatch) -> SQBool;
}
extern "C" {
pub fn sqstd_format(
v: HSQUIRRELVM,
nformatstringidx: SQInteger,
outlen: *mut SQInteger,
output: *mut *mut SQChar,
) -> SQRESULT;
}
extern "C" {
pub fn sqstd_pushstringf(v: HSQUIRRELVM, s: *const SQChar, ...);
}
extern "C" {
pub fn sqstd_register_stringlib(v: HSQUIRRELVM) -> SQRESULT;
}
extern "C" {
pub fn sqstd_register_systemlib(v: HSQUIRRELVM) -> SQInteger;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SQWeakRef {
pub _address: u8,
}