| /* automatically generated by rust-bindgen */ | |
| extern crate libc; | |
| use libc::size_t; | |
| use libc::ssize_t; | |
| #[repr(C)] | |
| pub struct ErlDrvSysInfo { | |
| pub driver_major_version: ::libc::c_int, | |
| pub driver_minor_version: ::libc::c_int, | |
| pub erts_version: *mut ::libc::c_char, | |
| pub otp_release: *mut ::libc::c_char, | |
| pub thread_support: ::libc::c_int, | |
| pub smp_support: ::libc::c_int, | |
| pub async_threads: ::libc::c_int, | |
| pub scheduler_threads: ::libc::c_int, | |
| pub nif_major_version: ::libc::c_int, | |
| pub nif_minor_version: ::libc::c_int, | |
| } | |
| #[repr(C)] | |
| pub struct ErlDrvThreadOpts { | |
| pub suggested_stack_size: ::libc::c_int, | |
| } | |
| #[repr(C)] | |
| pub struct SysIOVec { | |
| pub iov_base: *mut ::libc::c_char, | |
| pub iov_len: size_t, | |
| } | |
| pub type ErlDrvTermData = ::libc::c_ulong; | |
| pub type ErlDrvUInt = ::libc::c_ulong; | |
| pub type ErlDrvSInt = ::libc::c_long; | |
| pub type ErlDrvUInt64 = ::libc::c_ulong; | |
| pub type ErlDrvSInt64 = ::libc::c_long; | |
| pub type ErlDrvSizeT = size_t; | |
| pub type ErlDrvSSizeT = ssize_t; | |
| #[repr(C)] | |
| pub struct Struct_erl_drv_binary { | |
| pub orig_size: ErlDrvSInt, | |
| pub orig_bytes: [::libc::c_char, ..1u], | |
| } | |
| pub type ErlDrvBinary = Struct_erl_drv_binary; | |
| pub enum Struct__erl_drv_data { } | |
| pub type ErlDrvData = *mut Struct__erl_drv_data; | |
| pub enum Struct__erl_drv_event { } | |
| pub type ErlDrvEvent = *mut Struct__erl_drv_event; | |
| pub enum Struct__erl_drv_port { } | |
| pub type ErlDrvPort = *mut Struct__erl_drv_port; | |
| pub type ErlDrvThreadData = *mut Struct__erl_drv_port; | |
| #[repr(C)] | |
| pub struct Struct_erl_drv_event_data { | |
| pub events: ::libc::c_short, | |
| pub revents: ::libc::c_short, | |
| } | |
| pub type ErlDrvEventData = *mut Struct_erl_drv_event_data; | |
| #[repr(C)] | |
| pub struct ErlDrvMonitor { | |
| pub data: [::libc::c_uchar, ..32u], | |
| } | |
| #[repr(C)] | |
| pub struct ErlDrvNowData { | |
| pub megasecs: ::libc::c_ulong, | |
| pub secs: ::libc::c_ulong, | |
| pub microsecs: ::libc::c_ulong, | |
| } | |
| #[repr(C)] | |
| pub struct Struct_erl_io_vec { | |
| pub vsize: ::libc::c_int, | |
| pub size: ErlDrvSizeT, | |
| pub iov: *mut SysIOVec, | |
| pub binv: *mut *mut ErlDrvBinary, | |
| } | |
| pub type ErlIOVec = Struct_erl_io_vec; | |
| pub enum Struct_ErlDrvTid_ { } | |
| pub type ErlDrvTid = *mut Struct_ErlDrvTid_; | |
| pub enum Struct_ErlDrvMutex_ { } | |
| pub type ErlDrvMutex = Struct_ErlDrvMutex_; | |
| pub enum Struct_ErlDrvCond_ { } | |
| pub type ErlDrvCond = Struct_ErlDrvCond_; | |
| pub enum Struct_ErlDrvRWLock_ { } | |
| pub type ErlDrvRWLock = Struct_ErlDrvRWLock_; | |
| pub type ErlDrvTSDKey = ::libc::c_int; | |
| pub enum Struct_erl_drv_port_data_lock { } | |
| pub type ErlDrvPDL = *mut Struct_erl_drv_port_data_lock; | |
| #[repr(C)] | |
| pub struct Struct_erl_drv_entry { | |
| pub init: ::std::option::Option<extern "C" fn() -> ::libc::c_int>, | |
| pub start: ::std::option::Option<extern "C" fn | |
| (arg1: ErlDrvPort, | |
| arg2: *mut ::libc::c_char) | |
| -> ErlDrvData>, | |
| pub stop: ::std::option::Option<extern "C" fn(arg1: ErlDrvData)>, | |
| pub output: ::std::option::Option<extern "C" fn | |
| (arg1: ErlDrvData, | |
| arg2: *mut ::libc::c_char, | |
| arg3: ErlDrvSizeT)>, | |
| pub ready_input: ::std::option::Option<extern "C" fn | |
| (arg1: ErlDrvData, | |
| arg2: ErlDrvEvent)>, | |
| pub ready_output: ::std::option::Option<extern "C" fn | |
| (arg1: ErlDrvData, | |
| arg2: ErlDrvEvent)>, | |
| pub driver_name: *mut ::libc::c_char, | |
| pub finish: ::std::option::Option<extern "C" fn()>, | |
| pub handle: *mut ::libc::c_void, | |
| pub control: ::std::option::Option<extern "C" fn | |
| (arg1: ErlDrvData, | |
| arg2: ::libc::c_uint, | |
| arg3: *mut ::libc::c_char, | |
| arg4: ErlDrvSizeT, | |
| arg5: *mut *mut ::libc::c_char, | |
| arg6: ErlDrvSizeT) | |
| -> ErlDrvSSizeT>, | |
| pub timeout: ::std::option::Option<extern "C" fn(arg1: ErlDrvData)>, | |
| pub outputv: ::std::option::Option<extern "C" fn | |
| (arg1: ErlDrvData, | |
| arg2: *mut ErlIOVec)>, | |
| pub ready_async: ::std::option::Option<extern "C" fn | |
| (arg1: ErlDrvData, | |
| arg2: ErlDrvThreadData)>, | |
| pub flush: ::std::option::Option<extern "C" fn(arg1: ErlDrvData)>, | |
| pub call: ::std::option::Option<extern "C" fn | |
| (arg1: ErlDrvData, | |
| arg2: ::libc::c_uint, | |
| arg3: *mut ::libc::c_char, | |
| arg4: ErlDrvSizeT, | |
| arg5: *mut *mut ::libc::c_char, | |
| arg6: ErlDrvSizeT, | |
| arg7: *mut ::libc::c_uint) | |
| -> ErlDrvSSizeT>, | |
| pub event: ::std::option::Option<extern "C" fn | |
| (arg1: ErlDrvData, arg2: ErlDrvEvent, | |
| arg3: ErlDrvEventData)>, | |
| pub extended_marker: ::libc::c_int, | |
| pub major_version: ::libc::c_int, | |
| pub minor_version: ::libc::c_int, | |
| pub driver_flags: ::libc::c_int, | |
| pub handle2: *mut ::libc::c_void, | |
| pub process_exit: ::std::option::Option<extern "C" fn | |
| (arg1: ErlDrvData, | |
| arg2: *mut ErlDrvMonitor)>, | |
| pub stop_select: ::std::option::Option<extern "C" fn | |
| (arg1: ErlDrvEvent, | |
| arg2: *mut ::libc::c_void)>, | |
| } | |
| pub type ErlDrvEntry = Struct_erl_drv_entry; | |
| pub type ErlNifUInt64 = ::libc::c_ulong; | |
| pub type ErlNifSInt64 = ::libc::c_long; | |
| pub type ERL_NIF_TERM = ::libc::c_ulong; | |
| pub type ERL_NIF_UINT = ERL_NIF_TERM; | |
| pub enum Struct_enif_environment_t { } | |
| pub type ErlNifEnv = Struct_enif_environment_t; | |
| #[repr(C)] | |
| pub struct ErlNifFunc { | |
| pub name: *const ::libc::c_char, | |
| pub arity: ::libc::c_uint, | |
| pub fptr: ::std::option::Option<extern "C" fn | |
| (arg1: *mut ErlNifEnv, | |
| arg2: ::libc::c_int, | |
| arg3: *const ERL_NIF_TERM) | |
| -> ERL_NIF_TERM>, | |
| } | |
| #[repr(C)] | |
| pub struct Struct_enif_entry_t { | |
| pub major: ::libc::c_int, | |
| pub minor: ::libc::c_int, | |
| pub name: *const ::libc::c_char, | |
| pub num_of_funcs: ::libc::c_int, | |
| pub funcs: *mut ErlNifFunc, | |
| pub load: ::std::option::Option<extern "C" fn | |
| (arg1: *mut ErlNifEnv, | |
| arg2: *mut *mut ::libc::c_void, | |
| arg3: ERL_NIF_TERM) | |
| -> ::libc::c_int>, | |
| pub reload: ::std::option::Option<extern "C" fn | |
| (arg1: *mut ErlNifEnv, | |
| arg2: *mut *mut ::libc::c_void, | |
| arg3: ERL_NIF_TERM) | |
| -> ::libc::c_int>, | |
| pub upgrade: ::std::option::Option<extern "C" fn | |
| (arg1: *mut ErlNifEnv, | |
| arg2: *mut *mut ::libc::c_void, | |
| arg3: *mut *mut ::libc::c_void, | |
| arg4: ERL_NIF_TERM) | |
| -> ::libc::c_int>, | |
| pub unload: ::std::option::Option<extern "C" fn | |
| (arg1: *mut ErlNifEnv, | |
| arg2: *mut ::libc::c_void)>, | |
| pub vm_variant: *const ::libc::c_char, | |
| } | |
| pub type ErlNifEntry = Struct_enif_entry_t; | |
| #[repr(C)] | |
| pub struct ErlNifBinary { | |
| pub size: size_t, | |
| pub data: *mut ::libc::c_uchar, | |
| pub bin_term: ERL_NIF_TERM, | |
| pub ref_bin: *mut ::libc::c_void, | |
| } | |
| pub enum Struct_enif_resource_type_t { } | |
| pub type ErlNifResourceType = Struct_enif_resource_type_t; | |
| pub type ErlNifResourceDtor = ::libc::c_void; | |
| pub type ErlNifResourceFlags = ::libc::c_uint; | |
| pub static ERL_NIF_RT_CREATE: ::libc::c_uint = 1; | |
| pub static ERL_NIF_RT_TAKEOVER: ::libc::c_uint = 2; | |
| pub type ErlNifCharEncoding = ::libc::c_uint; | |
| pub static ERL_NIF_LATIN1: ::libc::c_uint = 1; | |
| #[repr(C)] | |
| pub struct ErlNifPid { | |
| pub pid: ERL_NIF_TERM, | |
| } | |
| pub type ErlNifSysInfo = ErlDrvSysInfo; | |
| pub type ErlNifTid = *mut Struct_ErlDrvTid_; | |
| pub type ErlNifMutex = Struct_ErlDrvMutex_; | |
| pub type ErlNifCond = Struct_ErlDrvCond_; | |
| pub type ErlNifRWLock = Struct_ErlDrvRWLock_; | |
| pub type ErlNifTSDKey = ::libc::c_int; | |
| pub type ErlNifThreadOpts = ErlDrvThreadOpts; | |
| #[repr(C)] | |
| pub struct ErlNifMapIterator { | |
| pub map: ERL_NIF_TERM, | |
| pub t_limit: ERL_NIF_UINT, | |
| pub idx: ERL_NIF_UINT, | |
| pub ks: *mut ERL_NIF_TERM, | |
| pub vs: *mut ERL_NIF_TERM, | |
| pub __spare__: [*mut ::libc::c_void, ..2u], | |
| } | |
| pub type ErlNifMapIteratorEntry = ::libc::c_uint; | |
| pub static ERL_NIF_MAP_ITERATOR_HEAD: ::libc::c_uint = 1; | |
| pub static ERL_NIF_MAP_ITERATOR_TAIL: ::libc::c_uint = 2; | |
| #[link(name = "erl_nif")] | |
| extern "C" { | |
| pub static driver_term_nil: ErlDrvTermData; | |
| pub fn erl_drv_busy_msgq_limits(port: ErlDrvPort, low: *mut ErlDrvSizeT, | |
| high: *mut ErlDrvSizeT); | |
| pub fn driver_select(port: ErlDrvPort, event: ErlDrvEvent, | |
| mode: ::libc::c_int, on: ::libc::c_int) -> | |
| ::libc::c_int; | |
| pub fn driver_event(port: ErlDrvPort, event: ErlDrvEvent, | |
| event_data: ErlDrvEventData) -> ::libc::c_int; | |
| pub fn driver_output(port: ErlDrvPort, buf: *mut ::libc::c_char, | |
| len: ErlDrvSizeT) -> ::libc::c_int; | |
| pub fn driver_output2(port: ErlDrvPort, hbuf: *mut ::libc::c_char, | |
| hlen: ErlDrvSizeT, buf: *mut ::libc::c_char, | |
| len: ErlDrvSizeT) -> ::libc::c_int; | |
| pub fn driver_output_binary(port: ErlDrvPort, hbuf: *mut ::libc::c_char, | |
| hlen: ErlDrvSizeT, bin: *mut ErlDrvBinary, | |
| offset: ErlDrvSizeT, len: ErlDrvSizeT) -> | |
| ::libc::c_int; | |
| pub fn driver_outputv(port: ErlDrvPort, hbuf: *mut ::libc::c_char, | |
| hlen: ErlDrvSizeT, ev: *mut ErlIOVec, | |
| skip: ErlDrvSizeT) -> ::libc::c_int; | |
| pub fn driver_vec_to_buf(ev: *mut ErlIOVec, buf: *mut ::libc::c_char, | |
| len: ErlDrvSizeT) -> ErlDrvSizeT; | |
| pub fn driver_set_timer(port: ErlDrvPort, time: ::libc::c_ulong) -> | |
| ::libc::c_int; | |
| pub fn driver_cancel_timer(port: ErlDrvPort) -> ::libc::c_int; | |
| pub fn driver_read_timer(port: ErlDrvPort, | |
| time_left: *mut ::libc::c_ulong) -> | |
| ::libc::c_int; | |
| pub fn erl_drv_consume_timeslice(port: ErlDrvPort, percent: ::libc::c_int) | |
| -> ::libc::c_int; | |
| pub fn erl_errno_id(error: ::libc::c_int) -> *mut ::libc::c_char; | |
| pub fn driver_failure_eof(port: ErlDrvPort) -> ::libc::c_int; | |
| pub fn driver_failure_atom(port: ErlDrvPort, string: *mut ::libc::c_char) | |
| -> ::libc::c_int; | |
| pub fn driver_failure_posix(port: ErlDrvPort, error: ::libc::c_int) -> | |
| ::libc::c_int; | |
| pub fn driver_failure(port: ErlDrvPort, error: ::libc::c_int) -> | |
| ::libc::c_int; | |
| pub fn driver_exit(port: ErlDrvPort, err: ::libc::c_int) -> ::libc::c_int; | |
| pub fn driver_pdl_create(arg1: ErlDrvPort) -> ErlDrvPDL; | |
| pub fn driver_pdl_lock(arg1: ErlDrvPDL); | |
| pub fn driver_pdl_unlock(arg1: ErlDrvPDL); | |
| pub fn driver_pdl_get_refc(arg1: ErlDrvPDL) -> ErlDrvSInt; | |
| pub fn driver_pdl_inc_refc(arg1: ErlDrvPDL) -> ErlDrvSInt; | |
| pub fn driver_pdl_dec_refc(arg1: ErlDrvPDL) -> ErlDrvSInt; | |
| pub fn driver_monitor_process(port: ErlDrvPort, process: ErlDrvTermData, | |
| monitor: *mut ErlDrvMonitor) -> | |
| ::libc::c_int; | |
| pub fn driver_demonitor_process(port: ErlDrvPort, | |
| monitor: *const ErlDrvMonitor) -> | |
| ::libc::c_int; | |
| pub fn driver_get_monitored_process(port: ErlDrvPort, | |
| monitor: *const ErlDrvMonitor) -> | |
| ErlDrvTermData; | |
| pub fn driver_compare_monitors(monitor1: *const ErlDrvMonitor, | |
| monitor2: *const ErlDrvMonitor) -> | |
| ::libc::c_int; | |
| pub fn set_busy_port(port: ErlDrvPort, on: ::libc::c_int); | |
| pub fn set_port_control_flags(port: ErlDrvPort, flags: ::libc::c_int); | |
| pub fn get_port_flags(port: ErlDrvPort) -> ::libc::c_int; | |
| pub fn driver_alloc_binary(size: ErlDrvSizeT) -> *mut ErlDrvBinary; | |
| pub fn driver_realloc_binary(bin: *mut ErlDrvBinary, size: ErlDrvSizeT) -> | |
| *mut ErlDrvBinary; | |
| pub fn driver_free_binary(bin: *mut ErlDrvBinary); | |
| pub fn driver_binary_get_refc(dbp: *mut ErlDrvBinary) -> ErlDrvSInt; | |
| pub fn driver_binary_inc_refc(dbp: *mut ErlDrvBinary) -> ErlDrvSInt; | |
| pub fn driver_binary_dec_refc(dbp: *mut ErlDrvBinary) -> ErlDrvSInt; | |
| pub fn driver_alloc(size: ErlDrvSizeT) -> *mut ::libc::c_void; | |
| pub fn driver_realloc(ptr: *mut ::libc::c_void, size: ErlDrvSizeT) -> | |
| *mut ::libc::c_void; | |
| pub fn driver_free(ptr: *mut ::libc::c_void); | |
| pub fn driver_enq(port: ErlDrvPort, buf: *mut ::libc::c_char, | |
| len: ErlDrvSizeT) -> ::libc::c_int; | |
| pub fn driver_pushq(port: ErlDrvPort, buf: *mut ::libc::c_char, | |
| len: ErlDrvSizeT) -> ::libc::c_int; | |
| pub fn driver_deq(port: ErlDrvPort, size: ErlDrvSizeT) -> ErlDrvSizeT; | |
| pub fn driver_sizeq(port: ErlDrvPort) -> ErlDrvSizeT; | |
| pub fn driver_enq_bin(port: ErlDrvPort, bin: *mut ErlDrvBinary, | |
| offset: ErlDrvSizeT, len: ErlDrvSizeT) -> | |
| ::libc::c_int; | |
| pub fn driver_pushq_bin(port: ErlDrvPort, bin: *mut ErlDrvBinary, | |
| offset: ErlDrvSizeT, len: ErlDrvSizeT) -> | |
| ::libc::c_int; | |
| pub fn driver_peekqv(port: ErlDrvPort, ev: *mut ErlIOVec) -> ErlDrvSizeT; | |
| pub fn driver_peekq(port: ErlDrvPort, vlen: *mut ::libc::c_int) -> | |
| *mut SysIOVec; | |
| pub fn driver_enqv(port: ErlDrvPort, ev: *mut ErlIOVec, skip: ErlDrvSizeT) | |
| -> ::libc::c_int; | |
| pub fn driver_pushqv(port: ErlDrvPort, ev: *mut ErlIOVec, | |
| skip: ErlDrvSizeT) -> ::libc::c_int; | |
| pub fn add_driver_entry(de: *mut ErlDrvEntry); | |
| pub fn remove_driver_entry(de: *mut ErlDrvEntry) -> ::libc::c_int; | |
| pub fn driver_system_info(sip: *mut ErlDrvSysInfo, si_size: size_t); | |
| pub fn erl_drv_mutex_create(name: *mut ::libc::c_char) -> | |
| *mut ErlDrvMutex; | |
| pub fn erl_drv_mutex_destroy(mtx: *mut ErlDrvMutex); | |
| pub fn erl_drv_mutex_trylock(mtx: *mut ErlDrvMutex) -> ::libc::c_int; | |
| pub fn erl_drv_mutex_lock(mtx: *mut ErlDrvMutex); | |
| pub fn erl_drv_mutex_unlock(mtx: *mut ErlDrvMutex); | |
| pub fn erl_drv_cond_create(name: *mut ::libc::c_char) -> *mut ErlDrvCond; | |
| pub fn erl_drv_cond_destroy(cnd: *mut ErlDrvCond); | |
| pub fn erl_drv_cond_signal(cnd: *mut ErlDrvCond); | |
| pub fn erl_drv_cond_broadcast(cnd: *mut ErlDrvCond); | |
| pub fn erl_drv_cond_wait(cnd: *mut ErlDrvCond, mtx: *mut ErlDrvMutex); | |
| pub fn erl_drv_rwlock_create(name: *mut ::libc::c_char) -> | |
| *mut ErlDrvRWLock; | |
| pub fn erl_drv_rwlock_destroy(rwlck: *mut ErlDrvRWLock); | |
| pub fn erl_drv_rwlock_tryrlock(rwlck: *mut ErlDrvRWLock) -> ::libc::c_int; | |
| pub fn erl_drv_rwlock_rlock(rwlck: *mut ErlDrvRWLock); | |
| pub fn erl_drv_rwlock_runlock(rwlck: *mut ErlDrvRWLock); | |
| pub fn erl_drv_rwlock_tryrwlock(rwlck: *mut ErlDrvRWLock) -> | |
| ::libc::c_int; | |
| pub fn erl_drv_rwlock_rwlock(rwlck: *mut ErlDrvRWLock); | |
| pub fn erl_drv_rwlock_rwunlock(rwlck: *mut ErlDrvRWLock); | |
| pub fn erl_drv_tsd_key_create(name: *mut ::libc::c_char, | |
| key: *mut ErlDrvTSDKey) -> ::libc::c_int; | |
| pub fn erl_drv_tsd_key_destroy(key: ErlDrvTSDKey); | |
| pub fn erl_drv_tsd_set(key: ErlDrvTSDKey, data: *mut ::libc::c_void); | |
| pub fn erl_drv_tsd_get(key: ErlDrvTSDKey) -> *mut ::libc::c_void; | |
| pub fn erl_drv_thread_opts_create(name: *mut ::libc::c_char) -> | |
| *mut ErlDrvThreadOpts; | |
| pub fn erl_drv_thread_opts_destroy(opts: *mut ErlDrvThreadOpts); | |
| pub fn erl_drv_thread_create(name: *mut ::libc::c_char, | |
| tid: *mut ErlDrvTid, | |
| func: | |
| ::std::option::Option<extern "C" fn | |
| (arg1: | |
| *mut ::libc::c_void) | |
| -> | |
| *mut ::libc::c_void>, | |
| args: *mut ::libc::c_void, | |
| opts: *mut ErlDrvThreadOpts) -> | |
| ::libc::c_int; | |
| pub fn erl_drv_thread_self() -> ErlDrvTid; | |
| pub fn erl_drv_equal_tids(tid1: ErlDrvTid, tid2: ErlDrvTid) -> | |
| ::libc::c_int; | |
| pub fn erl_drv_thread_exit(resp: *mut ::libc::c_void); | |
| pub fn erl_drv_thread_join(arg1: ErlDrvTid, | |
| respp: *mut *mut ::libc::c_void) -> | |
| ::libc::c_int; | |
| pub fn erl_drv_mutex_name(mtx: *mut ErlDrvMutex) -> *mut ::libc::c_char; | |
| pub fn erl_drv_cond_name(cnd: *mut ErlDrvCond) -> *mut ::libc::c_char; | |
| pub fn erl_drv_rwlock_name(rwlck: *mut ErlDrvRWLock) -> | |
| *mut ::libc::c_char; | |
| pub fn erl_drv_thread_name(tid: ErlDrvTid) -> *mut ::libc::c_char; | |
| pub fn null_func() -> ::libc::c_int; | |
| pub fn driver_mk_atom(arg1: *mut ::libc::c_char) -> ErlDrvTermData; | |
| pub fn driver_mk_port(arg1: ErlDrvPort) -> ErlDrvTermData; | |
| pub fn driver_connected(arg1: ErlDrvPort) -> ErlDrvTermData; | |
| pub fn driver_caller(arg1: ErlDrvPort) -> ErlDrvTermData; | |
| pub fn driver_mk_term_nil() -> ErlDrvTermData; | |
| pub fn driver_create_port(creator_port: ErlDrvPort, | |
| connected: ErlDrvTermData, | |
| name: *mut ::libc::c_char, drv_data: ErlDrvData) | |
| -> ErlDrvPort; | |
| pub fn driver_output_term(ix: ErlDrvPort, data: *mut ErlDrvTermData, | |
| len: ::libc::c_int) -> ::libc::c_int; | |
| pub fn driver_send_term(ix: ErlDrvPort, to: ErlDrvTermData, | |
| data: *mut ErlDrvTermData, len: ::libc::c_int) -> | |
| ::libc::c_int; | |
| pub fn erl_drv_output_term(port: ErlDrvTermData, | |
| data: *mut ErlDrvTermData, len: ::libc::c_int) | |
| -> ::libc::c_int; | |
| pub fn erl_drv_send_term(port: ErlDrvTermData, to: ErlDrvTermData, | |
| data: *mut ErlDrvTermData, len: ::libc::c_int) -> | |
| ::libc::c_int; | |
| pub fn driver_async_port_key(port: ErlDrvPort) -> ::libc::c_uint; | |
| pub fn driver_async(ix: ErlDrvPort, key: *mut ::libc::c_uint, | |
| async_invoke: | |
| ::std::option::Option<extern "C" fn | |
| (arg1: | |
| *mut ::libc::c_void)>, | |
| async_data: *mut ::libc::c_void, | |
| async_free: | |
| ::std::option::Option<extern "C" fn | |
| (arg1: | |
| *mut ::libc::c_void)>) | |
| -> ::libc::c_long; | |
| pub fn driver_lock_driver(ix: ErlDrvPort) -> ::libc::c_int; | |
| pub fn driver_get_now(now: *mut ErlDrvNowData) -> ::libc::c_int; | |
| pub fn driver_dl_open(arg1: *mut ::libc::c_char) -> *mut ::libc::c_void; | |
| pub fn driver_dl_sym(arg1: *mut ::libc::c_void, arg2: *mut ::libc::c_char) | |
| -> *mut ::libc::c_void; | |
| pub fn driver_dl_close(arg1: *mut ::libc::c_void) -> ::libc::c_int; | |
| pub fn driver_dl_error() -> *mut ::libc::c_char; | |
| pub fn erl_drv_putenv(key: *mut ::libc::c_char, | |
| value: *mut ::libc::c_char) -> ::libc::c_int; | |
| pub fn erl_drv_getenv(key: *mut ::libc::c_char, | |
| value: *mut ::libc::c_char, value_size: *mut size_t) | |
| -> ::libc::c_int; | |
| pub fn dtrace_drvport_str(port: ErlDrvPort, | |
| port_buf: *mut ::libc::c_char); | |
| pub fn enif_priv_data(arg1: *mut ErlNifEnv) -> *mut ::libc::c_void; | |
| pub fn enif_alloc(size: size_t) -> *mut ::libc::c_void; | |
| pub fn enif_free(ptr: *mut ::libc::c_void); | |
| pub fn enif_is_atom(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| pub fn enif_is_binary(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| pub fn enif_is_ref(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| pub fn enif_inspect_binary(arg1: *mut ErlNifEnv, bin_term: ERL_NIF_TERM, | |
| bin: *mut ErlNifBinary) -> ::libc::c_int; | |
| pub fn enif_alloc_binary(size: size_t, bin: *mut ErlNifBinary) -> | |
| ::libc::c_int; | |
| pub fn enif_realloc_binary(bin: *mut ErlNifBinary, size: size_t) -> | |
| ::libc::c_int; | |
| pub fn enif_release_binary(bin: *mut ErlNifBinary); | |
| pub fn enif_get_int(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM, | |
| ip: *mut ::libc::c_int) -> ::libc::c_int; | |
| pub fn enif_get_ulong(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM, | |
| ip: *mut ::libc::c_ulong) -> ::libc::c_int; | |
| pub fn enif_get_double(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM, | |
| dp: *mut ::libc::c_double) -> ::libc::c_int; | |
| pub fn enif_get_list_cell(env: *mut ErlNifEnv, term: ERL_NIF_TERM, | |
| head: *mut ERL_NIF_TERM, | |
| tail: *mut ERL_NIF_TERM) -> ::libc::c_int; | |
| pub fn enif_get_tuple(env: *mut ErlNifEnv, tpl: ERL_NIF_TERM, | |
| arity: *mut ::libc::c_int, | |
| array: *mut *const ERL_NIF_TERM) -> ::libc::c_int; | |
| pub fn enif_is_identical(lhs: ERL_NIF_TERM, rhs: ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| pub fn enif_compare(lhs: ERL_NIF_TERM, rhs: ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| pub fn enif_make_binary(env: *mut ErlNifEnv, bin: *mut ErlNifBinary) -> | |
| ERL_NIF_TERM; | |
| pub fn enif_make_badarg(env: *mut ErlNifEnv) -> ERL_NIF_TERM; | |
| pub fn enif_make_int(env: *mut ErlNifEnv, i: ::libc::c_int) -> | |
| ERL_NIF_TERM; | |
| pub fn enif_make_ulong(env: *mut ErlNifEnv, i: ::libc::c_ulong) -> | |
| ERL_NIF_TERM; | |
| pub fn enif_make_double(env: *mut ErlNifEnv, d: ::libc::c_double) -> | |
| ERL_NIF_TERM; | |
| pub fn enif_make_atom(env: *mut ErlNifEnv, name: *const ::libc::c_char) -> | |
| ERL_NIF_TERM; | |
| pub fn enif_make_existing_atom(env: *mut ErlNifEnv, | |
| name: *const ::libc::c_char, | |
| atom: *mut ERL_NIF_TERM, | |
| arg1: ErlNifCharEncoding) -> ::libc::c_int; | |
| pub fn enif_make_tuple(env: *mut ErlNifEnv, cnt: ::libc::c_uint, ...) -> | |
| ERL_NIF_TERM; | |
| pub fn enif_make_list(env: *mut ErlNifEnv, cnt: ::libc::c_uint, ...) -> | |
| ERL_NIF_TERM; | |
| pub fn enif_make_list_cell(env: *mut ErlNifEnv, car: ERL_NIF_TERM, | |
| cdr: ERL_NIF_TERM) -> ERL_NIF_TERM; | |
| pub fn enif_make_string(env: *mut ErlNifEnv, | |
| string: *const ::libc::c_char, | |
| arg1: ErlNifCharEncoding) -> ERL_NIF_TERM; | |
| pub fn enif_make_ref(env: *mut ErlNifEnv) -> ERL_NIF_TERM; | |
| pub fn enif_mutex_create(name: *mut ::libc::c_char) -> *mut ErlNifMutex; | |
| pub fn enif_mutex_destroy(mtx: *mut ErlNifMutex); | |
| pub fn enif_mutex_trylock(mtx: *mut ErlNifMutex) -> ::libc::c_int; | |
| pub fn enif_mutex_lock(mtx: *mut ErlNifMutex); | |
| pub fn enif_mutex_unlock(mtx: *mut ErlNifMutex); | |
| pub fn enif_cond_create(name: *mut ::libc::c_char) -> *mut ErlNifCond; | |
| pub fn enif_cond_destroy(cnd: *mut ErlNifCond); | |
| pub fn enif_cond_signal(cnd: *mut ErlNifCond); | |
| pub fn enif_cond_broadcast(cnd: *mut ErlNifCond); | |
| pub fn enif_cond_wait(cnd: *mut ErlNifCond, mtx: *mut ErlNifMutex); | |
| pub fn enif_rwlock_create(name: *mut ::libc::c_char) -> *mut ErlNifRWLock; | |
| pub fn enif_rwlock_destroy(rwlck: *mut ErlNifRWLock); | |
| pub fn enif_rwlock_tryrlock(rwlck: *mut ErlNifRWLock) -> ::libc::c_int; | |
| pub fn enif_rwlock_rlock(rwlck: *mut ErlNifRWLock); | |
| pub fn enif_rwlock_runlock(rwlck: *mut ErlNifRWLock); | |
| pub fn enif_rwlock_tryrwlock(rwlck: *mut ErlNifRWLock) -> ::libc::c_int; | |
| pub fn enif_rwlock_rwlock(rwlck: *mut ErlNifRWLock); | |
| pub fn enif_rwlock_rwunlock(rwlck: *mut ErlNifRWLock); | |
| pub fn enif_tsd_key_create(name: *mut ::libc::c_char, | |
| key: *mut ErlNifTSDKey) -> ::libc::c_int; | |
| pub fn enif_tsd_key_destroy(key: ErlNifTSDKey); | |
| pub fn enif_tsd_set(key: ErlNifTSDKey, data: *mut ::libc::c_void); | |
| pub fn enif_tsd_get(key: ErlNifTSDKey) -> *mut ::libc::c_void; | |
| pub fn enif_thread_opts_create(name: *mut ::libc::c_char) -> | |
| *mut ErlNifThreadOpts; | |
| pub fn enif_thread_opts_destroy(opts: *mut ErlNifThreadOpts); | |
| pub fn enif_thread_create(name: *mut ::libc::c_char, tid: *mut ErlNifTid, | |
| func: | |
| ::std::option::Option<extern "C" fn | |
| (arg1: | |
| *mut ::libc::c_void) | |
| -> | |
| *mut ::libc::c_void>, | |
| args: *mut ::libc::c_void, | |
| opts: *mut ErlNifThreadOpts) -> ::libc::c_int; | |
| pub fn enif_thread_self() -> ErlNifTid; | |
| pub fn enif_equal_tids(tid1: ErlNifTid, tid2: ErlNifTid) -> ::libc::c_int; | |
| pub fn enif_thread_exit(resp: *mut ::libc::c_void); | |
| pub fn enif_thread_join(arg1: ErlNifTid, respp: *mut *mut ::libc::c_void) | |
| -> ::libc::c_int; | |
| pub fn enif_realloc(ptr: *mut ::libc::c_void, size: size_t) -> | |
| *mut ::libc::c_void; | |
| pub fn enif_system_info(sip: *mut ErlNifSysInfo, si_size: size_t); | |
| pub fn enif_fprintf(filep: *mut ::libc::c_void, | |
| format: *const ::libc::c_char, ...) -> ::libc::c_int; | |
| pub fn enif_inspect_iolist_as_binary(arg1: *mut ErlNifEnv, | |
| term: ERL_NIF_TERM, | |
| bin: *mut ErlNifBinary) -> | |
| ::libc::c_int; | |
| pub fn enif_make_sub_binary(arg1: *mut ErlNifEnv, bin_term: ERL_NIF_TERM, | |
| pos: size_t, size: size_t) -> ERL_NIF_TERM; | |
| pub fn enif_get_string(arg1: *mut ErlNifEnv, list: ERL_NIF_TERM, | |
| buf: *mut ::libc::c_char, len: ::libc::c_uint, | |
| arg2: ErlNifCharEncoding) -> ::libc::c_int; | |
| pub fn enif_get_atom(arg1: *mut ErlNifEnv, atom: ERL_NIF_TERM, | |
| buf: *mut ::libc::c_char, len: ::libc::c_uint, | |
| arg2: ErlNifCharEncoding) -> ::libc::c_int; | |
| pub fn enif_is_fun(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| pub fn enif_is_pid(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| pub fn enif_is_port(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| pub fn enif_get_uint(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM, | |
| ip: *mut ::libc::c_uint) -> ::libc::c_int; | |
| pub fn enif_get_long(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM, | |
| ip: *mut ::libc::c_long) -> ::libc::c_int; | |
| pub fn enif_make_uint(arg1: *mut ErlNifEnv, i: ::libc::c_uint) -> | |
| ERL_NIF_TERM; | |
| pub fn enif_make_long(arg1: *mut ErlNifEnv, i: ::libc::c_long) -> | |
| ERL_NIF_TERM; | |
| pub fn enif_make_tuple_from_array(arg1: *mut ErlNifEnv, | |
| arr: *const ERL_NIF_TERM, | |
| cnt: ::libc::c_uint) -> ERL_NIF_TERM; | |
| pub fn enif_make_list_from_array(arg1: *mut ErlNifEnv, | |
| arr: *const ERL_NIF_TERM, | |
| cnt: ::libc::c_uint) -> ERL_NIF_TERM; | |
| pub fn enif_is_empty_list(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| pub fn enif_open_resource_type(arg1: *mut ErlNifEnv, | |
| module_str: *const ::libc::c_char, | |
| name_str: *const ::libc::c_char, | |
| dtor: | |
| ::std::option::Option<extern "C" fn | |
| (arg1: | |
| *mut ErlNifEnv, | |
| arg2: | |
| *mut ::libc::c_void)>, | |
| flags: ErlNifResourceFlags, | |
| tried: *mut ErlNifResourceFlags) -> | |
| *mut ErlNifResourceType; | |
| pub fn enif_alloc_resource(_type: *mut ErlNifResourceType, size: size_t) | |
| -> *mut ::libc::c_void; | |
| pub fn enif_release_resource(obj: *mut ::libc::c_void); | |
| pub fn enif_make_resource(arg1: *mut ErlNifEnv, obj: *mut ::libc::c_void) | |
| -> ERL_NIF_TERM; | |
| pub fn enif_get_resource(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM, | |
| _type: *mut ErlNifResourceType, | |
| objp: *mut *mut ::libc::c_void) -> ::libc::c_int; | |
| pub fn enif_sizeof_resource(obj: *mut ::libc::c_void) -> size_t; | |
| pub fn enif_make_new_binary(arg1: *mut ErlNifEnv, size: size_t, | |
| termp: *mut ERL_NIF_TERM) -> | |
| *mut ::libc::c_uchar; | |
| pub fn enif_is_list(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| pub fn enif_is_tuple(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| pub fn enif_get_atom_length(arg1: *mut ErlNifEnv, atom: ERL_NIF_TERM, | |
| len: *mut ::libc::c_uint, | |
| arg2: ErlNifCharEncoding) -> ::libc::c_int; | |
| pub fn enif_get_list_length(env: *mut ErlNifEnv, term: ERL_NIF_TERM, | |
| len: *mut ::libc::c_uint) -> ::libc::c_int; | |
| pub fn enif_make_atom_len(env: *mut ErlNifEnv, | |
| name: *const ::libc::c_char, len: size_t) -> | |
| ERL_NIF_TERM; | |
| pub fn enif_make_existing_atom_len(env: *mut ErlNifEnv, | |
| name: *const ::libc::c_char, | |
| len: size_t, atom: *mut ERL_NIF_TERM, | |
| arg1: ErlNifCharEncoding) -> | |
| ::libc::c_int; | |
| pub fn enif_make_string_len(env: *mut ErlNifEnv, | |
| string: *const ::libc::c_char, len: size_t, | |
| arg1: ErlNifCharEncoding) -> ERL_NIF_TERM; | |
| pub fn enif_alloc_env() -> *mut ErlNifEnv; | |
| pub fn enif_free_env(env: *mut ErlNifEnv); | |
| pub fn enif_clear_env(env: *mut ErlNifEnv); | |
| pub fn enif_send(env: *mut ErlNifEnv, to_pid: *const ErlNifPid, | |
| msg_env: *mut ErlNifEnv, msg: ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| pub fn enif_make_copy(dst_env: *mut ErlNifEnv, src_term: ERL_NIF_TERM) -> | |
| ERL_NIF_TERM; | |
| pub fn enif_self(caller_env: *mut ErlNifEnv, pid: *mut ErlNifPid) -> | |
| *mut ErlNifPid; | |
| pub fn enif_get_local_pid(env: *mut ErlNifEnv, arg1: ERL_NIF_TERM, | |
| pid: *mut ErlNifPid) -> ::libc::c_int; | |
| pub fn enif_keep_resource(obj: *mut ::libc::c_void); | |
| pub fn enif_make_resource_binary(arg1: *mut ErlNifEnv, | |
| obj: *mut ::libc::c_void, | |
| data: *const ::libc::c_void, | |
| size: size_t) -> ERL_NIF_TERM; | |
| pub fn enif_is_exception(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| pub fn enif_make_reverse_list(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM, | |
| list: *mut ERL_NIF_TERM) -> ::libc::c_int; | |
| pub fn enif_is_number(arg1: *mut ErlNifEnv, term: ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| pub fn enif_dlopen(lib: *const ::libc::c_char, | |
| err_handler: | |
| ::std::option::Option<extern "C" fn | |
| (arg1: | |
| *mut ::libc::c_void, | |
| arg2: | |
| *const ::libc::c_char)>, | |
| err_arg: *mut ::libc::c_void) -> *mut ::libc::c_void; | |
| pub fn enif_dlsym(handle: *mut ::libc::c_void, | |
| symbol: *const ::libc::c_char, | |
| err_handler: | |
| ::std::option::Option<extern "C" fn | |
| (arg1: | |
| *mut ::libc::c_void, | |
| arg2: | |
| *const ::libc::c_char)>, | |
| err_arg: *mut ::libc::c_void) -> *mut ::libc::c_void; | |
| pub fn enif_consume_timeslice(arg1: *mut ErlNifEnv, | |
| percent: ::libc::c_int) -> ::libc::c_int; | |
| pub fn enif_is_map(env: *mut ErlNifEnv, term: ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| pub fn enif_get_map_size(env: *mut ErlNifEnv, term: ERL_NIF_TERM, | |
| size: *mut size_t) -> ::libc::c_int; | |
| pub fn enif_make_new_map(env: *mut ErlNifEnv) -> ERL_NIF_TERM; | |
| pub fn enif_make_map_put(env: *mut ErlNifEnv, map_in: ERL_NIF_TERM, | |
| key: ERL_NIF_TERM, value: ERL_NIF_TERM, | |
| map_out: *mut ERL_NIF_TERM) -> ::libc::c_int; | |
| pub fn enif_get_map_value(env: *mut ErlNifEnv, map: ERL_NIF_TERM, | |
| key: ERL_NIF_TERM, value: *mut ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| pub fn enif_make_map_update(env: *mut ErlNifEnv, map_in: ERL_NIF_TERM, | |
| key: ERL_NIF_TERM, value: ERL_NIF_TERM, | |
| map_out: *mut ERL_NIF_TERM) -> ::libc::c_int; | |
| pub fn enif_make_map_remove(env: *mut ErlNifEnv, map_in: ERL_NIF_TERM, | |
| key: ERL_NIF_TERM, map_out: *mut ERL_NIF_TERM) | |
| -> ::libc::c_int; | |
| pub fn enif_map_iterator_create(env: *mut ErlNifEnv, map: ERL_NIF_TERM, | |
| iter: *mut ErlNifMapIterator, | |
| entry: ErlNifMapIteratorEntry) -> | |
| ::libc::c_int; | |
| pub fn enif_map_iterator_destroy(env: *mut ErlNifEnv, | |
| iter: *mut ErlNifMapIterator); | |
| pub fn enif_map_iterator_is_head(env: *mut ErlNifEnv, | |
| iter: *mut ErlNifMapIterator) -> | |
| ::libc::c_int; | |
| pub fn enif_map_iterator_is_tail(env: *mut ErlNifEnv, | |
| iter: *mut ErlNifMapIterator) -> | |
| ::libc::c_int; | |
| pub fn enif_map_iterator_next(env: *mut ErlNifEnv, | |
| iter: *mut ErlNifMapIterator) -> | |
| ::libc::c_int; | |
| pub fn enif_map_iterator_prev(env: *mut ErlNifEnv, | |
| iter: *mut ErlNifMapIterator) -> | |
| ::libc::c_int; | |
| pub fn enif_map_iterator_get_pair(env: *mut ErlNifEnv, | |
| iter: *mut ErlNifMapIterator, | |
| key: *mut ERL_NIF_TERM, | |
| value: *mut ERL_NIF_TERM) -> | |
| ::libc::c_int; | |
| } |
Using https://github.com/crabtw/rust-bindgen
$ cat gen.h
#include <erl_driver.h>
#include <erl_nif.h>
#include <erl_drv_nif.h>
$ bindgen -l erl_nif -match erl_drv_nif -match erl_driver -match erl_nif -o erl_nif.rs gen.h -I .../otp/erts/emulator/beam/ -I .../otp/erts/include/x86_64-unknown-linux-gnu