pub const s1cMAX: u32 = 127;
pub const s1cMIN: i32 = -127;
pub const s2cMAX: u32 = 32767;
pub const s2cMIN: i32 = -32767;
pub const s4cMAX: u32 = 2147483647;
pub const s4cMIN: i32 = -2147483647;
pub type u1c = ::std::os::raw::c_uchar;
pub type s1c = ::std::os::raw::c_schar;
pub type u2c = ::std::os::raw::c_ushort;
pub type s2c = ::std::os::raw::c_short;
pub type u4c = ::std::os::raw::c_ulong;
pub type s4c = ::std::os::raw::c_long;
pub type s8c = ::std::os::raw::c_longlong;
pub type u8c = ::std::os::raw::c_ulonglong;
#[repr(C)]
#[derive(Copy, Clone)]
pub union u4cOrPointer {
pub num: u4c,
pub ptr: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_u4cOrPointer() {
const UNINIT: ::std::mem::MaybeUninit<u4cOrPointer> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<u4cOrPointer>(),
4usize,
concat!("Size of: ", stringify!(u4cOrPointer))
);
assert_eq!(
::std::mem::align_of::<u4cOrPointer>(),
4usize,
concat!("Alignment of ", stringify!(u4cOrPointer))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(u4cOrPointer),
"::",
stringify!(num)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(u4cOrPointer),
"::",
stringify!(ptr)
)
);
}
pub type ByondValueType = u1c;
#[repr(C)]
#[derive(Copy, Clone)]
pub union ByondValueData {
pub ref_: u4c,
pub num: f32,
pub str_: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_ByondValueData() {
const UNINIT: ::std::mem::MaybeUninit<ByondValueData> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ByondValueData>(),
4usize,
concat!("Size of: ", stringify!(ByondValueData))
);
assert_eq!(
::std::mem::align_of::<ByondValueData>(),
4usize,
concat!("Alignment of ", stringify!(ByondValueData))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ref_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ByondValueData),
"::",
stringify!(ref_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ByondValueData),
"::",
stringify!(num)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).str_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ByondValueData),
"::",
stringify!(str_)
)
);
}
#[repr(C)]
pub struct CByondValue {
pub type_: ByondValueType,
pub junk1: u1c,
pub junk2: u1c,
pub junk3: u1c,
pub data: ByondValueData,
}
#[test]
fn bindgen_test_layout_CByondValue() {
const UNINIT: ::std::mem::MaybeUninit<CByondValue> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<CByondValue>(),
8usize,
concat!("Size of: ", stringify!(CByondValue))
);
assert_eq!(
::std::mem::align_of::<CByondValue>(),
4usize,
concat!("Alignment of ", stringify!(CByondValue))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(CByondValue),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).junk1) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(CByondValue),
"::",
stringify!(junk1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).junk2) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(CByondValue),
"::",
stringify!(junk2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).junk3) as usize - ptr as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(CByondValue),
"::",
stringify!(junk3)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(CByondValue),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug)]
pub struct CByondValueList {
pub items: *mut CByondValue,
pub count: u4c,
pub capacity: u4c,
}
#[test]
fn bindgen_test_layout_CByondValueList() {
const UNINIT: ::std::mem::MaybeUninit<CByondValueList> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<CByondValueList>(),
12usize,
concat!("Size of: ", stringify!(CByondValueList))
);
assert_eq!(
::std::mem::align_of::<CByondValueList>(),
4usize,
concat!("Alignment of ", stringify!(CByondValueList))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).items) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(CByondValueList),
"::",
stringify!(items)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(CByondValueList),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(CByondValueList),
"::",
stringify!(capacity)
)
);
}
extern crate libloading;
pub struct ByondApi {
__library: ::libloading::Library,
pub Byond_LastError: unsafe extern "C" fn() -> *const ::std::os::raw::c_char,
pub Byond_GetVersion: unsafe extern "C" fn(version: *mut u4c, build: *mut u4c),
pub ByondValue_Init: unsafe extern "C" fn(v: *mut CByondValue),
pub ByondValue_InitNum: unsafe extern "C" fn(v: *mut CByondValue, num: f32),
pub ByondValue_InitStr:
unsafe extern "C" fn(v: *mut CByondValue, str_: *const ::std::os::raw::c_char) -> bool,
pub ByondValue_InitRef:
unsafe extern "C" fn(v: *mut CByondValue, type_: ByondValueType, ref_: u4c),
pub ByondValue_Free: unsafe extern "C" fn(v: *mut CByondValue),
pub ByondValue_CopyFrom: unsafe extern "C" fn(dst: *mut CByondValue, src: *const CByondValue),
pub ByondValue_MoveFrom: unsafe extern "C" fn(dst: *mut CByondValue, src: *mut CByondValue),
pub ByondValue_Type: unsafe extern "C" fn(v: *const CByondValue) -> ByondValueType,
pub ByondValue_IsNull: unsafe extern "C" fn(v: *const CByondValue) -> bool,
pub ByondValue_IsNum: unsafe extern "C" fn(v: *const CByondValue) -> bool,
pub ByondValue_IsStr: unsafe extern "C" fn(v: *const CByondValue) -> bool,
pub ByondValue_IsList: unsafe extern "C" fn(v: *const CByondValue) -> bool,
pub ByondValue_GetNum: unsafe extern "C" fn(v: *const CByondValue) -> f32,
pub ByondValue_GetStr:
unsafe extern "C" fn(v: *const CByondValue) -> *const ::std::os::raw::c_char,
pub ByondValue_GetRef: unsafe extern "C" fn(v: *const CByondValue) -> u4c,
pub ByondValue_SetNum: unsafe extern "C" fn(v: *mut CByondValue, f: f32),
pub ByondValue_SetStr:
unsafe extern "C" fn(v: *mut CByondValue, str_: *const ::std::os::raw::c_char) -> bool,
pub ByondValue_SetRef:
unsafe extern "C" fn(v: *mut CByondValue, type_: ByondValueType, ref_: u4c),
pub ByondValue_Equals:
unsafe extern "C" fn(a: *const CByondValue, b: *const CByondValue) -> bool,
pub ByondValueList_Init: unsafe extern "C" fn(list: *mut CByondValueList),
pub ByondValueList_InitCount:
unsafe extern "C" fn(list: *mut CByondValueList, count: u4c) -> bool,
pub ByondValueList_Free: unsafe extern "C" fn(list: *mut CByondValueList),
pub ByondValueList_CopyFrom:
unsafe extern "C" fn(dst: *mut CByondValueList, src: *const CByondValueList) -> bool,
pub ByondValueList_MoveFrom:
unsafe extern "C" fn(dst: *mut CByondValueList, src: *mut CByondValueList),
pub ByondValueList_SetCount:
unsafe extern "C" fn(list: *mut CByondValueList, count: u4c) -> bool,
pub ByondValueList_Add:
unsafe extern "C" fn(list: *mut CByondValueList, v: *const CByondValue) -> bool,
pub ByondValueList_InsertAt: unsafe extern "C" fn(
list: *mut CByondValueList,
idx: ::std::os::raw::c_int,
v: *const CByondValue,
) -> bool,
pub ByondValueList_Splice: unsafe extern "C" fn(
list: *mut CByondValueList,
idx: ::std::os::raw::c_int,
delete_count: u4c,
v: *const CByondValue,
insert_count: u4c,
) -> bool,
pub ByondValueList_RemoveAt:
unsafe extern "C" fn(list: *mut CByondValueList, idx: u4c, n: u4c) -> u4c,
pub Byond_GetStrId: unsafe extern "C" fn(str_: *const ::std::os::raw::c_char) -> u4c,
pub Byond_ReadVar: unsafe extern "C" fn(
loc: *const CByondValue,
varname: *const ::std::os::raw::c_char,
result: *mut CByondValue,
) -> bool,
pub Byond_ReadVarByStrId: unsafe extern "C" fn(
loc: *const CByondValue,
varname: u4c,
result: *mut CByondValue,
) -> bool,
pub Byond_WriteVar: unsafe extern "C" fn(
loc: *const CByondValue,
varname: *const ::std::os::raw::c_char,
val: *const CByondValue,
) -> bool,
pub Byond_WriteVarByStrId: unsafe extern "C" fn(
loc: *const CByondValue,
varname: u4c,
val: *const CByondValue,
) -> bool,
pub Byond_CreateList: unsafe extern "C" fn(result: *mut CByondValue) -> bool,
pub Byond_ReadList:
unsafe extern "C" fn(loc: *const CByondValue, list: *mut CByondValueList) -> bool,
pub Byond_WriteList:
unsafe extern "C" fn(loc: *const CByondValue, list: *const CByondValueList) -> bool,
pub Byond_ReadListIndex: unsafe extern "C" fn(
loc: *const CByondValue,
idx: *const CByondValue,
result: *mut CByondValue,
) -> bool,
pub Byond_WriteListIndex: unsafe extern "C" fn(
loc: *const CByondValue,
idx: *const CByondValue,
val: *const CByondValue,
) -> bool,
pub Byond_ReadPointer:
unsafe extern "C" fn(ptr: *const CByondValue, result: *mut CByondValue) -> bool,
pub Byond_WritePointer:
unsafe extern "C" fn(ptr: *const CByondValue, val: *const CByondValue) -> bool,
pub Byond_CallProc: unsafe extern "C" fn(
src: *const CByondValue,
name: *const ::std::os::raw::c_char,
arg: *const CByondValue,
arg_count: u4c,
result: *mut CByondValue,
) -> bool,
pub Byond_CallProcByStrId: unsafe extern "C" fn(
src: *const CByondValue,
name: u4c,
arg: *const CByondValue,
arg_count: u4c,
result: *mut CByondValue,
) -> bool,
pub ByondValue_IncRef: unsafe extern "C" fn(src: *const CByondValue),
pub ByondValue_DecRef: unsafe extern "C" fn(src: *const CByondValue),
pub Byond_TestRef: unsafe extern "C" fn(src: *mut CByondValue) -> bool,
}
impl ByondApi {
pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
where
P: AsRef<::std::ffi::OsStr>,
{
let library = ::libloading::Library::new(path)?;
Self::from_library(library)
}
pub unsafe fn from_library<L>(library: L) -> Result<Self, ::libloading::Error>
where
L: Into<::libloading::Library>,
{
let __library = library.into();
let Byond_LastError = __library.get(b"Byond_LastError\0").map(|sym| *sym)?;
let Byond_GetVersion = __library.get(b"Byond_GetVersion\0").map(|sym| *sym)?;
let ByondValue_Init = __library.get(b"ByondValue_Init\0").map(|sym| *sym)?;
let ByondValue_InitNum = __library.get(b"ByondValue_InitNum\0").map(|sym| *sym)?;
let ByondValue_InitStr = __library.get(b"ByondValue_InitStr\0").map(|sym| *sym)?;
let ByondValue_InitRef = __library.get(b"ByondValue_InitRef\0").map(|sym| *sym)?;
let ByondValue_Free = __library.get(b"ByondValue_Free\0").map(|sym| *sym)?;
let ByondValue_CopyFrom = __library.get(b"ByondValue_CopyFrom\0").map(|sym| *sym)?;
let ByondValue_MoveFrom = __library.get(b"ByondValue_MoveFrom\0").map(|sym| *sym)?;
let ByondValue_Type = __library.get(b"ByondValue_Type\0").map(|sym| *sym)?;
let ByondValue_IsNull = __library.get(b"ByondValue_IsNull\0").map(|sym| *sym)?;
let ByondValue_IsNum = __library.get(b"ByondValue_IsNum\0").map(|sym| *sym)?;
let ByondValue_IsStr = __library.get(b"ByondValue_IsStr\0").map(|sym| *sym)?;
let ByondValue_IsList = __library.get(b"ByondValue_IsList\0").map(|sym| *sym)?;
let ByondValue_GetNum = __library.get(b"ByondValue_GetNum\0").map(|sym| *sym)?;
let ByondValue_GetStr = __library.get(b"ByondValue_GetStr\0").map(|sym| *sym)?;
let ByondValue_GetRef = __library.get(b"ByondValue_GetRef\0").map(|sym| *sym)?;
let ByondValue_SetNum = __library.get(b"ByondValue_SetNum\0").map(|sym| *sym)?;
let ByondValue_SetStr = __library.get(b"ByondValue_SetStr\0").map(|sym| *sym)?;
let ByondValue_SetRef = __library.get(b"ByondValue_SetRef\0").map(|sym| *sym)?;
let ByondValue_Equals = __library.get(b"ByondValue_Equals\0").map(|sym| *sym)?;
let ByondValueList_Init = __library.get(b"ByondValueList_Init\0").map(|sym| *sym)?;
let ByondValueList_InitCount = __library
.get(b"ByondValueList_InitCount\0")
.map(|sym| *sym)?;
let ByondValueList_Free = __library.get(b"ByondValueList_Free\0").map(|sym| *sym)?;
let ByondValueList_CopyFrom = __library
.get(b"ByondValueList_CopyFrom\0")
.map(|sym| *sym)?;
let ByondValueList_MoveFrom = __library
.get(b"ByondValueList_MoveFrom\0")
.map(|sym| *sym)?;
let ByondValueList_SetCount = __library
.get(b"ByondValueList_SetCount\0")
.map(|sym| *sym)?;
let ByondValueList_Add = __library.get(b"ByondValueList_Add\0").map(|sym| *sym)?;
let ByondValueList_InsertAt = __library
.get(b"ByondValueList_InsertAt\0")
.map(|sym| *sym)?;
let ByondValueList_Splice = __library.get(b"ByondValueList_Splice\0").map(|sym| *sym)?;
let ByondValueList_RemoveAt = __library
.get(b"ByondValueList_RemoveAt\0")
.map(|sym| *sym)?;
let Byond_GetStrId = __library.get(b"Byond_GetStrId\0").map(|sym| *sym)?;
let Byond_ReadVar = __library.get(b"Byond_ReadVar\0").map(|sym| *sym)?;
let Byond_ReadVarByStrId = __library.get(b"Byond_ReadVarByStrId\0").map(|sym| *sym)?;
let Byond_WriteVar = __library.get(b"Byond_WriteVar\0").map(|sym| *sym)?;
let Byond_WriteVarByStrId = __library.get(b"Byond_WriteVarByStrId\0").map(|sym| *sym)?;
let Byond_CreateList = __library.get(b"Byond_CreateList\0").map(|sym| *sym)?;
let Byond_ReadList = __library.get(b"Byond_ReadList\0").map(|sym| *sym)?;
let Byond_WriteList = __library.get(b"Byond_WriteList\0").map(|sym| *sym)?;
let Byond_ReadListIndex = __library.get(b"Byond_ReadListIndex\0").map(|sym| *sym)?;
let Byond_WriteListIndex = __library.get(b"Byond_WriteListIndex\0").map(|sym| *sym)?;
let Byond_ReadPointer = __library.get(b"Byond_ReadPointer\0").map(|sym| *sym)?;
let Byond_WritePointer = __library.get(b"Byond_WritePointer\0").map(|sym| *sym)?;
let Byond_CallProc = __library.get(b"Byond_CallProc\0").map(|sym| *sym)?;
let Byond_CallProcByStrId = __library.get(b"Byond_CallProcByStrId\0").map(|sym| *sym)?;
let ByondValue_IncRef = __library.get(b"ByondValue_IncRef\0").map(|sym| *sym)?;
let ByondValue_DecRef = __library.get(b"ByondValue_DecRef\0").map(|sym| *sym)?;
let Byond_TestRef = __library.get(b"Byond_TestRef\0").map(|sym| *sym)?;
Ok(ByondApi {
__library,
Byond_LastError,
Byond_GetVersion,
ByondValue_Init,
ByondValue_InitNum,
ByondValue_InitStr,
ByondValue_InitRef,
ByondValue_Free,
ByondValue_CopyFrom,
ByondValue_MoveFrom,
ByondValue_Type,
ByondValue_IsNull,
ByondValue_IsNum,
ByondValue_IsStr,
ByondValue_IsList,
ByondValue_GetNum,
ByondValue_GetStr,
ByondValue_GetRef,
ByondValue_SetNum,
ByondValue_SetStr,
ByondValue_SetRef,
ByondValue_Equals,
ByondValueList_Init,
ByondValueList_InitCount,
ByondValueList_Free,
ByondValueList_CopyFrom,
ByondValueList_MoveFrom,
ByondValueList_SetCount,
ByondValueList_Add,
ByondValueList_InsertAt,
ByondValueList_Splice,
ByondValueList_RemoveAt,
Byond_GetStrId,
Byond_ReadVar,
Byond_ReadVarByStrId,
Byond_WriteVar,
Byond_WriteVarByStrId,
Byond_CreateList,
Byond_ReadList,
Byond_WriteList,
Byond_ReadListIndex,
Byond_WriteListIndex,
Byond_ReadPointer,
Byond_WritePointer,
Byond_CallProc,
Byond_CallProcByStrId,
ByondValue_IncRef,
ByondValue_DecRef,
Byond_TestRef,
})
}
pub unsafe fn Byond_LastError(&self) -> *const ::std::os::raw::c_char {
(self.Byond_LastError)()
}
pub unsafe fn Byond_GetVersion(&self, version: *mut u4c, build: *mut u4c) {
(self.Byond_GetVersion)(version, build)
}
pub unsafe fn ByondValue_Init(&self, v: *mut CByondValue) {
(self.ByondValue_Init)(v)
}
pub unsafe fn ByondValue_InitNum(&self, v: *mut CByondValue, num: f32) {
(self.ByondValue_InitNum)(v, num)
}
pub unsafe fn ByondValue_InitStr(
&self,
v: *mut CByondValue,
str_: *const ::std::os::raw::c_char,
) -> bool {
(self.ByondValue_InitStr)(v, str_)
}
pub unsafe fn ByondValue_InitRef(&self, v: *mut CByondValue, type_: ByondValueType, ref_: u4c) {
(self.ByondValue_InitRef)(v, type_, ref_)
}
pub unsafe fn ByondValue_Free(&self, v: *mut CByondValue) {
(self.ByondValue_Free)(v)
}
pub unsafe fn ByondValue_CopyFrom(&self, dst: *mut CByondValue, src: *const CByondValue) {
(self.ByondValue_CopyFrom)(dst, src)
}
pub unsafe fn ByondValue_MoveFrom(&self, dst: *mut CByondValue, src: *mut CByondValue) {
(self.ByondValue_MoveFrom)(dst, src)
}
pub unsafe fn ByondValue_Type(&self, v: *const CByondValue) -> ByondValueType {
(self.ByondValue_Type)(v)
}
pub unsafe fn ByondValue_IsNull(&self, v: *const CByondValue) -> bool {
(self.ByondValue_IsNull)(v)
}
pub unsafe fn ByondValue_IsNum(&self, v: *const CByondValue) -> bool {
(self.ByondValue_IsNum)(v)
}
pub unsafe fn ByondValue_IsStr(&self, v: *const CByondValue) -> bool {
(self.ByondValue_IsStr)(v)
}
pub unsafe fn ByondValue_IsList(&self, v: *const CByondValue) -> bool {
(self.ByondValue_IsList)(v)
}
pub unsafe fn ByondValue_GetNum(&self, v: *const CByondValue) -> f32 {
(self.ByondValue_GetNum)(v)
}
pub unsafe fn ByondValue_GetStr(&self, v: *const CByondValue) -> *const ::std::os::raw::c_char {
(self.ByondValue_GetStr)(v)
}
pub unsafe fn ByondValue_GetRef(&self, v: *const CByondValue) -> u4c {
(self.ByondValue_GetRef)(v)
}
pub unsafe fn ByondValue_SetNum(&self, v: *mut CByondValue, f: f32) {
(self.ByondValue_SetNum)(v, f)
}
pub unsafe fn ByondValue_SetStr(
&self,
v: *mut CByondValue,
str_: *const ::std::os::raw::c_char,
) -> bool {
(self.ByondValue_SetStr)(v, str_)
}
pub unsafe fn ByondValue_SetRef(&self, v: *mut CByondValue, type_: ByondValueType, ref_: u4c) {
(self.ByondValue_SetRef)(v, type_, ref_)
}
pub unsafe fn ByondValue_Equals(&self, a: *const CByondValue, b: *const CByondValue) -> bool {
(self.ByondValue_Equals)(a, b)
}
pub unsafe fn ByondValueList_Init(&self, list: *mut CByondValueList) {
(self.ByondValueList_Init)(list)
}
pub unsafe fn ByondValueList_InitCount(&self, list: *mut CByondValueList, count: u4c) -> bool {
(self.ByondValueList_InitCount)(list, count)
}
pub unsafe fn ByondValueList_Free(&self, list: *mut CByondValueList) {
(self.ByondValueList_Free)(list)
}
pub unsafe fn ByondValueList_CopyFrom(
&self,
dst: *mut CByondValueList,
src: *const CByondValueList,
) -> bool {
(self.ByondValueList_CopyFrom)(dst, src)
}
pub unsafe fn ByondValueList_MoveFrom(
&self,
dst: *mut CByondValueList,
src: *mut CByondValueList,
) {
(self.ByondValueList_MoveFrom)(dst, src)
}
pub unsafe fn ByondValueList_SetCount(&self, list: *mut CByondValueList, count: u4c) -> bool {
(self.ByondValueList_SetCount)(list, count)
}
pub unsafe fn ByondValueList_Add(
&self,
list: *mut CByondValueList,
v: *const CByondValue,
) -> bool {
(self.ByondValueList_Add)(list, v)
}
pub unsafe fn ByondValueList_InsertAt(
&self,
list: *mut CByondValueList,
idx: ::std::os::raw::c_int,
v: *const CByondValue,
) -> bool {
(self.ByondValueList_InsertAt)(list, idx, v)
}
pub unsafe fn ByondValueList_Splice(
&self,
list: *mut CByondValueList,
idx: ::std::os::raw::c_int,
delete_count: u4c,
v: *const CByondValue,
insert_count: u4c,
) -> bool {
(self.ByondValueList_Splice)(list, idx, delete_count, v, insert_count)
}
pub unsafe fn ByondValueList_RemoveAt(
&self,
list: *mut CByondValueList,
idx: u4c,
n: u4c,
) -> u4c {
(self.ByondValueList_RemoveAt)(list, idx, n)
}
pub unsafe fn Byond_GetStrId(&self, str_: *const ::std::os::raw::c_char) -> u4c {
(self.Byond_GetStrId)(str_)
}
pub unsafe fn Byond_ReadVar(
&self,
loc: *const CByondValue,
varname: *const ::std::os::raw::c_char,
result: *mut CByondValue,
) -> bool {
(self.Byond_ReadVar)(loc, varname, result)
}
pub unsafe fn Byond_ReadVarByStrId(
&self,
loc: *const CByondValue,
varname: u4c,
result: *mut CByondValue,
) -> bool {
(self.Byond_ReadVarByStrId)(loc, varname, result)
}
pub unsafe fn Byond_WriteVar(
&self,
loc: *const CByondValue,
varname: *const ::std::os::raw::c_char,
val: *const CByondValue,
) -> bool {
(self.Byond_WriteVar)(loc, varname, val)
}
pub unsafe fn Byond_WriteVarByStrId(
&self,
loc: *const CByondValue,
varname: u4c,
val: *const CByondValue,
) -> bool {
(self.Byond_WriteVarByStrId)(loc, varname, val)
}
pub unsafe fn Byond_CreateList(&self, result: *mut CByondValue) -> bool {
(self.Byond_CreateList)(result)
}
pub unsafe fn Byond_ReadList(
&self,
loc: *const CByondValue,
list: *mut CByondValueList,
) -> bool {
(self.Byond_ReadList)(loc, list)
}
pub unsafe fn Byond_WriteList(
&self,
loc: *const CByondValue,
list: *const CByondValueList,
) -> bool {
(self.Byond_WriteList)(loc, list)
}
pub unsafe fn Byond_ReadListIndex(
&self,
loc: *const CByondValue,
idx: *const CByondValue,
result: *mut CByondValue,
) -> bool {
(self.Byond_ReadListIndex)(loc, idx, result)
}
pub unsafe fn Byond_WriteListIndex(
&self,
loc: *const CByondValue,
idx: *const CByondValue,
val: *const CByondValue,
) -> bool {
(self.Byond_WriteListIndex)(loc, idx, val)
}
pub unsafe fn Byond_ReadPointer(
&self,
ptr: *const CByondValue,
result: *mut CByondValue,
) -> bool {
(self.Byond_ReadPointer)(ptr, result)
}
pub unsafe fn Byond_WritePointer(
&self,
ptr: *const CByondValue,
val: *const CByondValue,
) -> bool {
(self.Byond_WritePointer)(ptr, val)
}
pub unsafe fn Byond_CallProc(
&self,
src: *const CByondValue,
name: *const ::std::os::raw::c_char,
arg: *const CByondValue,
arg_count: u4c,
result: *mut CByondValue,
) -> bool {
(self.Byond_CallProc)(src, name, arg, arg_count, result)
}
pub unsafe fn Byond_CallProcByStrId(
&self,
src: *const CByondValue,
name: u4c,
arg: *const CByondValue,
arg_count: u4c,
result: *mut CByondValue,
) -> bool {
(self.Byond_CallProcByStrId)(src, name, arg, arg_count, result)
}
pub unsafe fn ByondValue_IncRef(&self, src: *const CByondValue) {
(self.ByondValue_IncRef)(src)
}
pub unsafe fn ByondValue_DecRef(&self, src: *const CByondValue) {
(self.ByondValue_DecRef)(src)
}
pub unsafe fn Byond_TestRef(&self, src: *mut CByondValue) -> bool {
(self.Byond_TestRef)(src)
}
}