#![allow(bad_style)]
#![allow(unused)]
use rustmex_core::raw::*;
pub type SLIndex = i64;
pub type SLSize = i64;
pub type CHAR16_T = ::std::os::raw::c_ushort;
#[doc = " MEX-file entry point type"]
pub type mxFunctionPtr = ::std::option::Option<
unsafe extern "C" fn(
nlhs: ::std::os::raw::c_int,
plhs: *mut *mut mxArray,
nrhs: ::std::os::raw::c_int,
prhs: *mut *mut mxArray,
),
>;
#[doc = " Logical type"]
pub type mxLogical = bool;
#[doc = " Required for Unicode support in MATLAB"]
pub type mxChar = CHAR16_T;
pub type mxClassID = ::std::os::raw::c_uint;
#[doc = " Indicates whether floating-point mxArrays are real or complex."]
pub type mxComplexity = ::std::os::raw::c_uint;
pub type mxDouble = f64;
pub type mxSingle = f32;
pub type mxInt8 = i8;
pub type mxUint8 = u8;
pub type mxInt16 = i16;
pub type mxUint16 = u16;
pub type mxInt32 = i32;
pub type mxUint32 = u32;
pub type mxInt64 = i64;
pub type mxUint64 = u64;
pub type mxComplexDouble = ::num_complex::Complex<f64>;
pub type mxComplexSingle = ::num_complex::Complex<f32>;
pub type mxComplexInt8 = ::num_complex::Complex<i8>;
pub type mxComplexUint8 = ::num_complex::Complex<u8>;
pub type mxComplexInt16 = ::num_complex::Complex<i16>;
pub type mxComplexUint16 = ::num_complex::Complex<u16>;
pub type mxComplexInt32 = ::num_complex::Complex<i32>;
pub type mxComplexUint32 = ::num_complex::Complex<u32>;
pub type mxComplexInt64 = ::num_complex::Complex<i64>;
pub type mxComplexUint64 = ::num_complex::Complex<u64>;
type size_t = usize;
extern "C" {
pub fn mxMalloc_800(n: size_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn mxCalloc_800(n: size_t, size: size_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn mxFree_800(ptr: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn mxRealloc_800(
ptr: *mut ::std::os::raw::c_void,
size: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn mxGetNumberOfDimensions_800(pa: *const mxArray) -> mwSize;
}
extern "C" {
pub fn mxGetDimensions_800(pa: *const mxArray) -> *const mwSize;
}
extern "C" {
pub fn mxGetM_800(pa: *const mxArray) -> size_t;
}
extern "C" {
pub fn mxGetIr_800(pa: *const mxArray) -> *mut mwIndex;
}
extern "C" {
pub fn mxGetJc_800(pa: *const mxArray) -> *mut mwIndex;
}
extern "C" {
pub fn mxGetNzmax_800(pa: *const mxArray) -> mwSize;
}
extern "C" {
pub fn mxSetNzmax_800(pa: *mut mxArray, nzmax: mwSize);
}
extern "C" {
pub fn mxGetFieldNameByNumber_800(
pa: *const mxArray,
n: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn mxGetFieldByNumber_800(
pa: *const mxArray,
i: mwIndex,
fieldnum: ::std::os::raw::c_int,
) -> *mut mxArray;
}
extern "C" {
pub fn mxGetCell_800(pa: *const mxArray, i: mwIndex) -> *mut mxArray;
}
extern "C" {
pub fn mxGetClassID_800(pa: *const mxArray) -> mxClassID;
}
extern "C" {
pub fn mxGetData_800(pa: *const mxArray) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn mxSetData_800(pa: *mut mxArray, newdata: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn mxIsNumeric_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsCell_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsLogical_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsScalar_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsChar_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsStruct_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsOpaque_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsFunctionHandle_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsObject_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsComplex_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsSparse_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsDouble_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsSingle_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsInt8_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsUint8_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsInt16_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsUint16_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsInt32_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsUint32_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsInt64_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsUint64_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxGetNumberOfElements_800(pa: *const mxArray) -> size_t;
}
extern "C" {
pub fn mxGetChars_800(pa: *const mxArray) -> *mut mxChar;
}
extern "C" {
pub fn mxGetUserBits_800(pa: *const mxArray) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxSetUserBits_800(pa: *mut mxArray, value: ::std::os::raw::c_int);
}
extern "C" {
pub fn mxGetScalar_800(pa: *const mxArray) -> f64;
}
extern "C" {
pub fn mxIsFromGlobalWS_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxSetFromGlobalWS_800(pa: *mut mxArray, global: bool);
}
extern "C" {
pub fn mxSetM_800(pa: *mut mxArray, m: mwSize);
}
extern "C" {
pub fn mxGetN_800(pa: *const mxArray) -> size_t;
}
extern "C" {
pub fn mxIsEmpty_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxGetFieldNumber_800(
pa: *const mxArray,
name: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxSetIr_800(pa: *mut mxArray, newir: *mut mwIndex);
}
extern "C" {
pub fn mxSetJc_800(pa: *mut mxArray, newjc: *mut mwIndex);
}
extern "C" {
pub fn mxGetPr_800(pa: *const mxArray) -> *mut f64;
}
extern "C" {
pub fn mxSetPr_800(pa: *mut mxArray, newdata: *mut f64);
}
extern "C" {
pub fn mxGetElementSize_800(pa: *const mxArray) -> size_t;
}
extern "C" {
pub fn mxCalcSingleSubscript_800(
pa: *const mxArray,
nsubs: mwSize,
subs: *const mwIndex,
) -> mwIndex;
}
extern "C" {
pub fn mxGetNumberOfFields_800(pa: *const mxArray) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxSetCell_800(pa: *mut mxArray, i: mwIndex, value: *mut mxArray);
}
extern "C" {
pub fn mxSetFieldByNumber_800(
pa: *mut mxArray,
i: mwIndex,
fieldnum: ::std::os::raw::c_int,
value: *mut mxArray,
);
}
extern "C" {
pub fn mxGetField_800(
pa: *const mxArray,
i: mwIndex,
fieldname: *const ::std::os::raw::c_char,
) -> *mut mxArray;
}
extern "C" {
pub fn mxSetField_800(
pa: *mut mxArray,
i: mwIndex,
fieldname: *const ::std::os::raw::c_char,
value: *mut mxArray,
);
}
extern "C" {
pub fn mxGetProperty_800(
pa: *const mxArray,
i: mwIndex,
propname: *const ::std::os::raw::c_char,
) -> *mut mxArray;
}
extern "C" {
pub fn mxSetProperty_800(
pa: *mut mxArray,
i: mwIndex,
propname: *const ::std::os::raw::c_char,
value: *const mxArray,
);
}
extern "C" {
pub fn mxGetClassName_800(pa: *const mxArray) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn mxIsClass_800(pa: *const mxArray, name: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
pub fn mxCreateNumericMatrix_800(
m: mwSize,
n: mwSize,
classid: mxClassID,
flag: mxComplexity,
) -> *mut mxArray;
}
extern "C" {
pub fn mxCreateUninitNumericMatrix_800(
m: size_t,
n: size_t,
classid: mxClassID,
flag: mxComplexity,
) -> *mut mxArray;
}
extern "C" {
pub fn mxCreateUninitNumericArray_800(
ndim: size_t,
dims: *mut size_t,
classid: mxClassID,
flag: mxComplexity,
) -> *mut mxArray;
}
extern "C" {
pub fn mxSetN_800(pa: *mut mxArray, n: mwSize);
}
extern "C" {
pub fn mxSetDimensions_800(
pa: *mut mxArray,
pdims: *const mwSize,
ndims: mwSize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxDestroyArray_800(pa: *mut mxArray);
}
extern "C" {
pub fn mxCreateNumericArray_800(
ndim: mwSize,
dims: *const mwSize,
classid: mxClassID,
flag: mxComplexity,
) -> *mut mxArray;
}
extern "C" {
pub fn mxCreateCharArray_800(ndim: mwSize, dims: *const mwSize) -> *mut mxArray;
}
extern "C" {
pub fn mxCreateDoubleMatrix_800(m: mwSize, n: mwSize, flag: mxComplexity) -> *mut mxArray;
}
extern "C" {
pub fn mxGetLogicals_800(pa: *const mxArray) -> *mut mxLogical;
}
extern "C" {
pub fn mxCreateLogicalArray_800(ndim: mwSize, dims: *const mwSize) -> *mut mxArray;
}
extern "C" {
pub fn mxCreateLogicalMatrix_800(m: mwSize, n: mwSize) -> *mut mxArray;
}
extern "C" {
pub fn mxCreateLogicalScalar_800(value: bool) -> *mut mxArray;
}
extern "C" {
pub fn mxIsLogicalScalar_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxIsLogicalScalarTrue_800(pa: *const mxArray) -> bool;
}
extern "C" {
pub fn mxCreateDoubleScalar_800(value: f64) -> *mut mxArray;
}
extern "C" {
pub fn mxCreateSparse_800(
m: mwSize,
n: mwSize,
nzmax: mwSize,
flag: mxComplexity,
) -> *mut mxArray;
}
extern "C" {
pub fn mxCreateSparseLogicalMatrix_800(m: mwSize, n: mwSize, nzmax: mwSize) -> *mut mxArray;
}
extern "C" {
pub fn mxGetNChars_800(pa: *const mxArray, buf: *mut ::std::os::raw::c_char, nChars: mwSize);
}
extern "C" {
pub fn mxGetString_800(
pa: *const mxArray,
buf: *mut ::std::os::raw::c_char,
buflen: mwSize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxArrayToString_800(pa: *const mxArray) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn mxArrayToUTF8String_800(pa: *const mxArray) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn mxCreateStringFromNChars_800(
str_: *const ::std::os::raw::c_char,
n: mwSize,
) -> *mut mxArray;
}
extern "C" {
pub fn mxCreateString_800(str_: *const ::std::os::raw::c_char) -> *mut mxArray;
}
extern "C" {
pub fn mxCreateCharMatrixFromStrings_800(
m: mwSize,
str_: *mut *const ::std::os::raw::c_char,
) -> *mut mxArray;
}
extern "C" {
pub fn mxCreateCellMatrix_800(m: mwSize, n: mwSize) -> *mut mxArray;
}
extern "C" {
pub fn mxCreateCellArray_800(ndim: mwSize, dims: *const mwSize) -> *mut mxArray;
}
extern "C" {
pub fn mxCreateStructMatrix_800(
m: mwSize,
n: mwSize,
nfields: ::std::os::raw::c_int,
fieldnames: *mut *const ::std::os::raw::c_char,
) -> *mut mxArray;
}
extern "C" {
pub fn mxCreateStructArray_800(
ndim: mwSize,
dims: *const mwSize,
nfields: ::std::os::raw::c_int,
fieldnames: *mut *const ::std::os::raw::c_char,
) -> *mut mxArray;
}
extern "C" {
pub fn mxDuplicateArray_800(in_: *const mxArray) -> *mut mxArray;
}
extern "C" {
pub fn mxSetClassName_800(
pa: *mut mxArray,
classname: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxAddField_800(
pa: *mut mxArray,
fieldname: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxRemoveField_800(pa: *mut mxArray, field: ::std::os::raw::c_int);
}
extern "C" {
pub fn mxGetEps_800() -> f64;
}
extern "C" {
pub fn mxGetInf_800() -> f64;
}
extern "C" {
pub fn mxGetNaN_800() -> f64;
}
extern "C" {
pub fn mxIsFinite_800(x: f64) -> bool;
}
extern "C" {
pub fn mxIsInf_800(x: f64) -> bool;
}
extern "C" {
pub fn mxIsNaN_800(x: f64) -> bool;
}
extern "C" {
pub fn mxGetDoubles_800(arg1: *const mxArray) -> *mut mxDouble;
}
extern "C" {
pub fn mxSetDoubles_800(arg1: *mut mxArray, arg2: *mut mxDouble) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetComplexDoubles_800(arg1: *const mxArray) -> *mut mxComplexDouble;
}
extern "C" {
pub fn mxSetComplexDoubles_800(
arg1: *mut mxArray,
arg2: *mut mxComplexDouble,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetSingles_800(arg1: *const mxArray) -> *mut mxSingle;
}
extern "C" {
pub fn mxSetSingles_800(arg1: *mut mxArray, arg2: *mut mxSingle) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetComplexSingles_800(arg1: *const mxArray) -> *mut mxComplexSingle;
}
extern "C" {
pub fn mxSetComplexSingles_800(
arg1: *mut mxArray,
arg2: *mut mxComplexSingle,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetInt8s_800(arg1: *const mxArray) -> *mut mxInt8;
}
extern "C" {
pub fn mxSetInt8s_800(arg1: *mut mxArray, arg2: *mut mxInt8) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetComplexInt8s_800(arg1: *const mxArray) -> *mut mxComplexInt8;
}
extern "C" {
pub fn mxSetComplexInt8s_800(
arg1: *mut mxArray,
arg2: *mut mxComplexInt8,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetUint8s_800(arg1: *const mxArray) -> *mut mxUint8;
}
extern "C" {
pub fn mxSetUint8s_800(arg1: *mut mxArray, arg2: *mut mxUint8) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetComplexUint8s_800(arg1: *const mxArray) -> *mut mxComplexUint8;
}
extern "C" {
pub fn mxSetComplexUint8s_800(
arg1: *mut mxArray,
arg2: *mut mxComplexUint8,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetInt16s_800(arg1: *const mxArray) -> *mut mxInt16;
}
extern "C" {
pub fn mxSetInt16s_800(arg1: *mut mxArray, arg2: *mut mxInt16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetComplexInt16s_800(arg1: *const mxArray) -> *mut mxComplexInt16;
}
extern "C" {
pub fn mxSetComplexInt16s_800(
arg1: *mut mxArray,
arg2: *mut mxComplexInt16,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetUint16s_800(arg1: *const mxArray) -> *mut mxUint16;
}
extern "C" {
pub fn mxSetUint16s_800(arg1: *mut mxArray, arg2: *mut mxUint16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetComplexUint16s_800(arg1: *const mxArray) -> *mut mxComplexUint16;
}
extern "C" {
pub fn mxSetComplexUint16s_800(
arg1: *mut mxArray,
arg2: *mut mxComplexUint16,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetInt32s_800(arg1: *const mxArray) -> *mut mxInt32;
}
extern "C" {
pub fn mxSetInt32s_800(arg1: *mut mxArray, arg2: *mut mxInt32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetComplexInt32s_800(arg1: *const mxArray) -> *mut mxComplexInt32;
}
extern "C" {
pub fn mxSetComplexInt32s_800(
arg1: *mut mxArray,
arg2: *mut mxComplexInt32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetUint32s_800(arg1: *const mxArray) -> *mut mxUint32;
}
extern "C" {
pub fn mxSetUint32s_800(arg1: *mut mxArray, arg2: *mut mxUint32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetComplexUint32s_800(arg1: *const mxArray) -> *mut mxComplexUint32;
}
extern "C" {
pub fn mxSetComplexUint32s_800(
arg1: *mut mxArray,
arg2: *mut mxComplexUint32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetInt64s_800(arg1: *const mxArray) -> *mut mxInt64;
}
extern "C" {
pub fn mxSetInt64s_800(arg1: *mut mxArray, arg2: *mut mxInt64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetComplexInt64s_800(arg1: *const mxArray) -> *mut mxComplexInt64;
}
extern "C" {
pub fn mxSetComplexInt64s_800(
arg1: *mut mxArray,
arg2: *mut mxComplexInt64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetUint64s_800(arg1: *const mxArray) -> *mut mxUint64;
}
extern "C" {
pub fn mxSetUint64s_800(arg1: *mut mxArray, arg2: *mut mxUint64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxGetComplexUint64s_800(arg1: *const mxArray) -> *mut mxComplexUint64;
}
extern "C" {
pub fn mxSetComplexUint64s_800(
arg1: *mut mxArray,
arg2: *mut mxComplexUint64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxMakeArrayReal_800(arg1: *mut mxArray) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mxMakeArrayComplex_800(arg1: *mut mxArray) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __assert_fail(
__assertion: *const ::std::os::raw::c_char,
__file: *const ::std::os::raw::c_char,
__line: ::std::os::raw::c_uint,
__function: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn __assert_perror_fail(
__errnum: ::std::os::raw::c_int,
__file: *const ::std::os::raw::c_char,
__line: ::std::os::raw::c_uint,
__function: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn __assert(
__assertion: *const ::std::os::raw::c_char,
__file: *const ::std::os::raw::c_char,
__line: ::std::os::raw::c_int,
);
}
pub type mex_exit_fn = ::std::option::Option<unsafe extern "C" fn()>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mexGlobalTableEntry_Tag {
pub name: *const ::std::os::raw::c_char,
pub variable: *mut *mut mxArray,
}
#[test]
fn bindgen_test_layout_mexGlobalTableEntry_Tag() {
assert_eq!(
::std::mem::size_of::<mexGlobalTableEntry_Tag>(),
16usize,
concat!("Size of: ", stringify!(mexGlobalTableEntry_Tag))
);
assert_eq!(
::std::mem::align_of::<mexGlobalTableEntry_Tag>(),
8usize,
concat!("Alignment of ", stringify!(mexGlobalTableEntry_Tag))
);
fn test_field_name() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<mexGlobalTableEntry_Tag>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(mexGlobalTableEntry_Tag),
"::",
stringify!(name)
)
);
}
test_field_name();
fn test_field_variable() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<mexGlobalTableEntry_Tag>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).variable) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(mexGlobalTableEntry_Tag),
"::",
stringify!(variable)
)
);
}
test_field_variable();
}
pub type mexGlobalTableEntry = mexGlobalTableEntry_Tag;
pub type mexGlobalTable = *mut mexGlobalTableEntry_Tag;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mexFunctionTableEntry_tag {
pub name: *const ::std::os::raw::c_char,
pub f: mxFunctionPtr,
pub nargin: ::std::os::raw::c_int,
pub nargout: ::std::os::raw::c_int,
pub local_function_table: *mut _mexLocalFunctionTable,
}
#[test]
fn bindgen_test_layout_mexFunctionTableEntry_tag() {
assert_eq!(
::std::mem::size_of::<mexFunctionTableEntry_tag>(),
32usize,
concat!("Size of: ", stringify!(mexFunctionTableEntry_tag))
);
assert_eq!(
::std::mem::align_of::<mexFunctionTableEntry_tag>(),
8usize,
concat!("Alignment of ", stringify!(mexFunctionTableEntry_tag))
);
fn test_field_name() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<mexFunctionTableEntry_tag>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(mexFunctionTableEntry_tag),
"::",
stringify!(name)
)
);
}
test_field_name();
fn test_field_f() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<mexFunctionTableEntry_tag>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(mexFunctionTableEntry_tag),
"::",
stringify!(f)
)
);
}
test_field_f();
fn test_field_nargin() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<mexFunctionTableEntry_tag>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).nargin) as usize - ptr as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(mexFunctionTableEntry_tag),
"::",
stringify!(nargin)
)
);
}
test_field_nargin();
fn test_field_nargout() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<mexFunctionTableEntry_tag>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).nargout) as usize - ptr as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(mexFunctionTableEntry_tag),
"::",
stringify!(nargout)
)
);
}
test_field_nargout();
fn test_field_local_function_table() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<mexFunctionTableEntry_tag>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).local_function_table) as usize - ptr as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(mexFunctionTableEntry_tag),
"::",
stringify!(local_function_table)
)
);
}
test_field_local_function_table();
}
pub type mexFunctionTableEntry = mexFunctionTableEntry_tag;
pub type mexFunctionTable = *mut mexFunctionTableEntry_tag;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _mexLocalFunctionTable {
pub length: size_t,
pub entries: mexFunctionTable,
}
#[test]
fn bindgen_test_layout__mexLocalFunctionTable() {
assert_eq!(
::std::mem::size_of::<_mexLocalFunctionTable>(),
16usize,
concat!("Size of: ", stringify!(_mexLocalFunctionTable))
);
assert_eq!(
::std::mem::align_of::<_mexLocalFunctionTable>(),
8usize,
concat!("Alignment of ", stringify!(_mexLocalFunctionTable))
);
fn test_field_length() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<_mexLocalFunctionTable>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mexLocalFunctionTable),
"::",
stringify!(length)
)
);
}
test_field_length();
fn test_field_entries() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<_mexLocalFunctionTable>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).entries) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_mexLocalFunctionTable),
"::",
stringify!(entries)
)
);
}
test_field_entries();
}
pub type mexLocalFunctionTable = *mut _mexLocalFunctionTable;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _mexInitTermTableEntry {
pub initialize: ::std::option::Option<unsafe extern "C" fn()>,
pub terminate: ::std::option::Option<unsafe extern "C" fn()>,
}
#[test]
fn bindgen_test_layout__mexInitTermTableEntry() {
assert_eq!(
::std::mem::size_of::<_mexInitTermTableEntry>(),
16usize,
concat!("Size of: ", stringify!(_mexInitTermTableEntry))
);
assert_eq!(
::std::mem::align_of::<_mexInitTermTableEntry>(),
8usize,
concat!("Alignment of ", stringify!(_mexInitTermTableEntry))
);
fn test_field_initialize() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<_mexInitTermTableEntry>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).initialize) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mexInitTermTableEntry),
"::",
stringify!(initialize)
)
);
}
test_field_initialize();
fn test_field_terminate() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<_mexInitTermTableEntry>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).terminate) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_mexInitTermTableEntry),
"::",
stringify!(terminate)
)
);
}
test_field_terminate();
}
pub type mexInitTermTableEntry = *mut _mexInitTermTableEntry;
pub type fn_clean_up_after_error = ::std::option::Option<unsafe extern "C" fn()>;
pub type fn_simple_function_to_string =
::std::option::Option<unsafe extern "C" fn(f: mxFunctionPtr) -> *const ::std::os::raw::c_char>;
pub type fn_mex_get_local_function_table =
::std::option::Option<unsafe extern "C" fn() -> mexLocalFunctionTable>;
pub type fn_mex_set_local_function_table = ::std::option::Option<
unsafe extern "C" fn(arg1: mexLocalFunctionTable) -> mexLocalFunctionTable,
>;
extern "C" {
pub fn mexErrMsgTxt_800(error_msg: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn mexErrMsgIdAndTxt_800(
identifier: *const ::std::os::raw::c_char,
err_msg: *const ::std::os::raw::c_char,
...
);
}
extern "C" {
pub fn mexWarnMsgTxt_800(warn_msg: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn mexWarnMsgIdAndTxt_800(
identifier: *const ::std::os::raw::c_char,
warn_msg: *const ::std::os::raw::c_char,
...
);
}
extern "C" {
pub fn mexPrintf_800(fmt: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mexMakeArrayPersistent_800(pa: *mut mxArray);
}
extern "C" {
pub fn mexMakeMemoryPersistent_800(ptr: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn mexCallMATLAB_800(
nlhs: ::std::os::raw::c_int,
plhs: *mut *mut mxArray,
nrhs: ::std::os::raw::c_int,
prhs: *mut *mut mxArray,
fcn_name: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mexCallMATLABWithTrap_800(
nlhs: ::std::os::raw::c_int,
plhs: *mut *mut mxArray,
nrhs: ::std::os::raw::c_int,
prhs: *mut *mut mxArray,
fcn_name: *const ::std::os::raw::c_char,
) -> *mut mxArray;
}
extern "C" {
pub fn mexPrintAssertion_800(
test: *const ::std::os::raw::c_char,
fname: *const ::std::os::raw::c_char,
linenum: ::std::os::raw::c_int,
message: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn mexIsGlobal_800(pA: *const mxArray) -> bool;
}
extern "C" {
pub fn mexPutVariable_800(
workspace: *const ::std::os::raw::c_char,
name: *const ::std::os::raw::c_char,
parray: *const mxArray,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mexGetVariablePtr_800(
workspace: *const ::std::os::raw::c_char,
name: *const ::std::os::raw::c_char,
) -> *const mxArray;
}
extern "C" {
pub fn mexGetVariable_800(
workspace: *const ::std::os::raw::c_char,
name: *const ::std::os::raw::c_char,
) -> *mut mxArray;
}
extern "C" {
pub fn mexLock_800();
}
extern "C" {
pub fn mexUnlock_800();
}
extern "C" {
pub fn mexIsLocked_800() -> bool;
}
extern "C" {
pub fn mexFunctionName_800() -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn mexEvalString_800(str_: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mexEvalStringWithTrap_800(str_: *const ::std::os::raw::c_char) -> *mut mxArray;
}
extern "C" {
pub fn mexAtExit_800(exit_fcn: mex_exit_fn) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mexFunction(
nlhs: ::std::os::raw::c_int,
plhs: *mut *mut mxArray,
nrhs: ::std::os::raw::c_int,
prhs: *mut *const mxArray,
);
}