MVP of Foreign Function Interface

src/ffi.rs

@@ -0,0 +1,369 @@
+use crate::atom_table::Atom;
+
+use std::alloc::{alloc, Layout};
+use std::any::Any;
+use std::collections::HashMap;
+use std::error::Error;
+use std::ffi::{CString, c_void};
+use std::convert::TryFrom;
+
+use libffi::low::{ffi_cif, types, CodePtr, ffi_abi_FFI_DEFAULT_ABI, prep_cif, ffi_type, type_tag};
+use libloading::{Symbol, Library};
+
+pub struct FunctionDefinition {
+    pub name: String,
+    pub return_value: Atom,
+    pub args: Vec<Atom>,
+}
+
+#[derive(Debug)]
+pub struct FunctionImpl {
+    cif: ffi_cif,
+    args: Vec<*mut ffi_type>,
+    code_ptr: CodePtr,
+    return_struct_name: Option<String>,
+}
+
+#[derive(Debug, Default)]
+pub struct ForeignFunctionTable {
+    table: HashMap<String, FunctionImpl>,
+    structs: HashMap<String, StructImpl>,
+}
+
+#[derive(Debug)]
+struct StructImpl {
+    ffi_type: ffi_type,
+    fields: Vec<*mut ffi_type>,
+}
+
+struct PointerArgs {
+    pointers: Vec<*mut c_void>,
+    memory: Vec<Box<dyn Any>>,
+}
+
+impl ForeignFunctionTable {
+    pub fn merge(&mut self, other: ForeignFunctionTable) {
+	self.table.extend(other.table);
+    }
+
+    pub fn define_struct(&mut self, name: &str, fields: Vec<Atom>) {
+	let mut fields: Vec<_> = fields.iter().map(|x| self.map_type_ffi(&x)).collect();
+	fields.push(std::ptr::null_mut::<ffi_type>());
+	let mut struct_type: ffi_type = Default::default();
+	struct_type.type_ = type_tag::STRUCT;
+	struct_type.elements = fields.as_mut_ptr();
+	self.structs.insert(name.to_string(), StructImpl { ffi_type: struct_type, fields});
+    }
+
+    fn map_type_ffi(&mut self, source: &Atom) -> *mut ffi_type {
+	unsafe {
+	match source {
+	    atom!("sint64") => &mut types::sint64,
+	    atom!("sint32") => &mut types::sint32,
+	    atom!("sint16") => &mut types::sint16,
+	    atom!("sint8") => &mut types::sint8,
+	    atom!("uint64") => &mut types::uint64,
+	    atom!("uint32") => &mut types::uint32,
+	    atom!("uint16") => &mut types::uint16,
+	    atom!("uint8") => &mut types::uint8,
+	    atom!("bool") => &mut types::sint8,
+	    atom!("void") => &mut types::void,
+	    atom!("cstr") => &mut types::pointer,
+	    atom!("ptr") => &mut types::pointer,
+	    atom!("f32") => &mut types::float,
+	    atom!("f64") => &mut types::double,
+	    struct_name => {
+		match self.structs.get_mut(struct_name.as_str()) {
+		    Some(ref mut struct_type) => {
+			&mut struct_type.ffi_type
+		    },
+		    None => unreachable!()
+		}
+	    }
+	}
+	}
+    }
+
+    pub(crate) fn load_library(&mut self, library_name: &str, functions: &Vec<FunctionDefinition>) -> Result<(), Box<dyn Error>> {
+	let mut ff_table: ForeignFunctionTable = Default::default();
+	unsafe {
+	    let library = Library::new(library_name)?;
+	    for function in functions {
+		let symbol_name: CString = CString::new(function.name.clone())?;
+		let code_ptr: Symbol<*mut c_void> = library.get(&symbol_name.into_bytes_with_nul())?;
+		let mut args: Vec<_> = function.args.iter().map(|x| self.map_type_ffi(&x)).collect();
+		let mut cif: ffi_cif = Default::default();
+		prep_cif(
+		    &mut cif,
+		    ffi_abi_FFI_DEFAULT_ABI,
+		    args.len(),
+		    self.map_type_ffi(&function.return_value),
+		    args.as_mut_ptr()
+		).unwrap();
+
+		let return_struct_name = if (*self.map_type_ffi(&function.return_value)).type_ as u32 == libffi::raw::FFI_TYPE_STRUCT {
+		    Some(function.return_value.as_str().to_string())
+		} else {
+		    None
+		};
+
+		ff_table.table.insert(function.name.clone(), FunctionImpl {
+		    cif,
+		    args,
+		    code_ptr: CodePtr(code_ptr.into_raw().into_raw() as *mut _),
+		    return_struct_name,
+		});
+	    }
+	    std::mem::forget(library);
+	}
+	self.merge(ff_table);
+	Ok(())
+    }
+
+    fn build_pointer_args(mut args: &mut Vec<Value>, type_args: &Vec<*mut ffi_type>, structs_table: &mut HashMap<String, StructImpl>) -> Result<PointerArgs, FFIError> {
+	let mut pointers = Vec::with_capacity(args.len());
+	let mut memory = Vec::new();
+	for i in 0..args.len() {
+	    let field_type = type_args[i];
+	    unsafe {
+		match (*field_type).type_ as u32 {
+		    libffi::raw::FFI_TYPE_UINT8 => {
+			let n: u8 = u8::try_from(args[i].as_int()?).map_err(|_| FFIError::ValueDontFit)?;
+			let mut box_value = Box::new(n) as Box<dyn Any>;
+			pointers.push(&mut *box_value as *mut _ as *mut c_void);
+			memory.push(box_value);
+		    },
+		    libffi::raw::FFI_TYPE_SINT8 => {
+			let n: i8 = i8::try_from(args[i].as_int()?).map_err(|_| FFIError::ValueDontFit)?;
+			let mut box_value = Box::new(n) as Box<dyn Any>;
+			pointers.push(&mut *box_value as *mut _ as *mut c_void);
+			memory.push(box_value);
+		    },
+		    libffi::raw::FFI_TYPE_UINT16 => {
+			let n: u16 = u16::try_from(args[i].as_int()?).map_err(|_| FFIError::ValueDontFit)?;
+			let mut box_value = Box::new(n) as Box<dyn Any>;
+			pointers.push(&mut *box_value as *mut _ as *mut c_void);
+			memory.push(box_value);
+		    },
+		    libffi::raw::FFI_TYPE_SINT16 => {
+			let n: i16 = i16::try_from(args[i].as_int()?).map_err(|_| FFIError::ValueDontFit)?;
+			let mut box_value = Box::new(n) as Box<dyn Any>;
+			pointers.push(&mut *box_value as *mut _ as *mut c_void);
+			memory.push(box_value);
+		    },
+		    libffi::raw::FFI_TYPE_UINT32 => {
+			let n: u32 = u32::try_from(args[i].as_int()?).map_err(|_| FFIError::ValueDontFit)?;
+			let mut box_value = Box::new(n) as Box<dyn Any>;
+			pointers.push(&mut *box_value as *mut _ as *mut c_void);
+			memory.push(box_value);
+		    },
+		    libffi::raw::FFI_TYPE_SINT32 => {
+			let n: i32 = i32::try_from(args[i].as_int()?).map_err(|_| FFIError::ValueDontFit)?;
+			let mut box_value = Box::new(n) as Box<dyn Any>;
+			pointers.push(&mut *box_value as *mut _ as *mut c_void);
+			memory.push(box_value);
+		    },
+		    libffi::raw::FFI_TYPE_UINT64 => {
+			let n: u64 = u64::try_from(args[i].as_int()?).map_err(|_| FFIError::ValueDontFit)?;
+			let mut box_value = Box::new(n) as Box<dyn Any>;
+			pointers.push(&mut *box_value as *mut _ as *mut c_void);
+			memory.push(box_value);
+		    },
+		    libffi::raw::FFI_TYPE_SINT64 => {
+			let n: i64 = args[i].as_int()?;
+			let mut box_value = Box::new(n) as Box<dyn Any>;
+			pointers.push(&mut *box_value as *mut _ as *mut c_void);
+			memory.push(box_value);
+		    },
+		    libffi::raw::FFI_TYPE_FLOAT => {
+			let n: f32 = args[i].as_float()? as f32;
+			let mut box_value = Box::new(n) as Box<dyn Any>;
+			pointers.push(&mut *box_value as *mut _ as *mut c_void);
+			memory.push(box_value);
+		    },
+		    libffi::raw::FFI_TYPE_DOUBLE => {
+			let n: f64 = args[i].as_float()?;
+			let mut box_value = Box::new(n) as Box<dyn Any>;
+			pointers.push(&mut *box_value as *mut _ as *mut c_void);
+			memory.push(box_value);
+		    },
+		    libffi::raw::FFI_TYPE_POINTER => {
+			let ptr: *mut c_void = args[i].as_ptr()?;
+			pointers.push(ptr);
+		    },
+		    libffi::raw::FFI_TYPE_STRUCT => {
+			match args[i] {
+			    Value::Struct(ref name, ref struct_args) => {
+				if let Some(ref mut struct_type) = structs_table.get_mut(name) {
+				    let layout = Layout::from_size_align(struct_type.ffi_type.size, struct_type.ffi_type.alignment.into()).unwrap();
+				    let ptr = alloc(layout) as *mut c_void;
+				    let mut field_ptr = ptr;
+				    for i in 0..(struct_type.fields.len()-1) {
+					let field = struct_type.fields[i];
+					match (*field).type_ as u32 {
+					    libffi::raw::FFI_TYPE_UINT8 => {
+						let n: u8 = u8::try_from(struct_args[i].as_int()?).map_err(|_| FFIError::ValueDontFit)?;
+						std::ptr::write(field_ptr as *mut u8, n);
+						field_ptr = field_ptr.add(std::mem::size_of::<u8>());
+					    },
+					    libffi::raw::FFI_TYPE_UINT32 => {
+						let n: u32 = u32::try_from(struct_args[i].as_int()?).map_err(|_| FFIError::ValueDontFit)?;
+						std::ptr::write(field_ptr as *mut u32, n);
+						field_ptr = field_ptr.add(std::mem::size_of::<u32>());
+					    },
+					    libffi::raw::FFI_TYPE_SINT32 => {
+						let n: u32 = u32::try_from(struct_args[i].as_int()?).map_err(|_| FFIError::ValueDontFit)?;
+						std::ptr::write(field_ptr as *mut u32, n);
+						field_ptr = field_ptr.add(std::mem::size_of::<u32>());
+					    },					    
+					    libffi::raw::FFI_TYPE_FLOAT => {
+						let n: f32 = struct_args[i].as_float()? as f32;
+						std::ptr::write(field_ptr as *mut f32, n);
+						field_ptr = field_ptr.add(std::mem::size_of::<f32>());
+					    },
+					    _ => {
+						unreachable!()
+					    }
+					}
+				    }
+				    pointers.push(ptr);
+				    memory.push(Box::from_raw(ptr));
+				} else {
+				    return Err(FFIError::InvalidStructName);
+				}
+			    }
+			    _ => return Err(FFIError::ValueCast)
+			}
+		    },
+		    _ => return Err(FFIError::InvalidFFIType)
+		}
+	    }
+	}
+	Ok(PointerArgs {
+	    pointers,
+	    memory
+	})
+    }
+
+    pub fn exec(&mut self, name: &str, mut args: Vec<Value>) -> Result<Value, FFIError> {
+	let function_impl = self.table.get_mut(name).ok_or(FFIError::FunctionNotFound)?;
+	let mut pointer_args = Self::build_pointer_args(&mut args, &function_impl.args, &mut self.structs).unwrap();
+	return unsafe {
+	    match (*function_impl.cif.rtype).type_ as u32 {
+		libffi::raw::FFI_TYPE_VOID => {
+		    let mut _n: Box<i32> = Box::new(0);
+		    libffi::raw::ffi_call(
+			&mut function_impl.cif,
+			Some(*function_impl.code_ptr.as_safe_fun()),
+			&mut *_n as *mut _ as *mut c_void,
+			pointer_args.pointers.as_mut_ptr() as *mut *mut c_void
+		    );
+		    Ok(Value::Int(0))
+		},
+		libffi::raw::FFI_TYPE_SINT8 => {
+		    let mut n: Box<i8> = Box::new(0);
+		    libffi::raw::ffi_call(
+			&mut function_impl.cif,
+			Some(*function_impl.code_ptr.as_safe_fun()),
+			&mut *n as *mut _ as *mut c_void,
+			pointer_args.pointers.as_mut_ptr() as *mut *mut c_void
+		    );
+		    Ok(Value::Int(i64::from(*n)))
+		},		    
+		libffi::raw::FFI_TYPE_SINT32 => {
+		    let mut n: Box<i32> = Box::new(0);
+		    libffi::raw::ffi_call(
+			&mut function_impl.cif,
+			Some(*function_impl.code_ptr.as_safe_fun()),
+			&mut *n as *mut _ as *mut c_void,
+			pointer_args.pointers.as_mut_ptr() as *mut *mut c_void
+		    );
+		    Ok(Value::Int(i64::from(*n)))
+		},
+		libffi::raw::FFI_TYPE_STRUCT => {
+		    let mut returns = Vec::new();
+		    let mut struct_type = self.structs.get_mut(&function_impl.return_struct_name.clone().ok_or(FFIError::StructNotFound)?).ok_or(FFIError::StructNotFound)?;
+		    let layout = Layout::from_size_align(struct_type.ffi_type.size, struct_type.ffi_type.alignment.into()).unwrap();
+		    let ptr = alloc(layout) as *mut c_void;
+		    libffi::raw::ffi_call(
+			&mut function_impl.cif,
+			Some(*function_impl.code_ptr.as_safe_fun()),
+			&mut *ptr as *mut _ as *mut c_void,
+			pointer_args.pointers.as_mut_ptr() as *mut *mut c_void
+		    );
+
+		    let mut field_ptr = ptr;
+		    for i in 0..(struct_type.fields.len()-1) {
+			let field = struct_type.fields[i];
+			match (*field).type_ as u32 {
+			    libffi::raw::FFI_TYPE_UINT8 => {
+				let n = std::ptr::read(field_ptr as *mut u8);
+				returns.push(Value::Int(i64::from(n)));
+				field_ptr = field_ptr.add(std::mem::size_of::<u8>());
+			    },
+			    libffi::raw::FFI_TYPE_SINT32 => {
+				let n = std::ptr::read(field_ptr as *mut i32);
+				returns.push(Value::Int(i64::from(n)));
+				field_ptr = field_ptr.add(std::mem::size_of::<i32>());
+			    },
+			    libffi::raw::FFI_TYPE_UINT32 => {
+				let n = std::ptr::read(field_ptr as *mut u32);
+				returns.push(Value::Int(i64::from(n)));
+				field_ptr = field_ptr.add(std::mem::size_of::<u32>());
+			    },
+			    _ => {
+				unreachable!()
+			    }
+			}
+		    }
+		    drop(Box::from_raw(ptr));
+		    Ok(Value::Struct("texture".into(), returns))
+		},
+	    _ => unreachable!()
+	    }
+	};
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum Value {
+    Int(i64),
+    Float(f64),
+    CString(CString),
+    Struct(String, Vec<Value>),
+}
+
+impl Value {
+    fn as_int(&self) -> Result<i64, FFIError> {
+	match self {
+	    Value::Int(n) => Ok(*n),
+	    _ => Err(FFIError::ValueCast),
+	}
+    }
+
+    fn as_float(&self) -> Result<f64, FFIError> {
+	match self {
+	    Value::Float(n) => Ok(*n),
+	    Value::Int(n) => Ok(*n as f64),
+	    _ => Err(FFIError::ValueCast),
+	}
+    }
+
+    fn as_ptr(&mut self) -> Result<*mut c_void, FFIError> {
+	match self {
+	    Value::CString(ref mut cstr) => Ok(&mut *cstr as *mut _ as *mut c_void),
+	    Value::Int(n) => Ok(*n as *mut c_void),
+	    _ => Err(FFIError::ValueCast)
+	}
+    }
+}
+
+#[derive(Debug)]
+pub enum FFIError {
+    ValueCast,
+    ValueDontFit,
+    InvalidFFIType,
+    InvalidStructName,
+    FunctionNotFound,
+    StructNotFound,
+}

src/lib.rs

@@ -15,6 +15,7 @@ mod allocator;
 mod arithmetic;
 pub mod codegen;
 mod debray_allocator;
+mod ffi;
 mod fixtures;
 mod forms;
 mod heap_iter;

src/lib/ffi.pl

@@ -0,0 +1,83 @@
+:- module(ffi, [use_foreign_module/2, foreign_struct/2]).
+
+:- use_module(library(lists)).
+:- use_module(library(error)).
+    
+foreign_struct(Name, Elements) :-
+    '$define_foreign_struct'(Name, Elements).
+
+use_foreign_module(LibName, Predicates) :-
+    '$load_foreign_lib'(LibName, Predicates),
+    maplist(assert_predicate, Predicates).
+
+assert_predicate(PredicateDefinition) :-
+    PredicateDefinition =.. [Name, Inputs, void],
+    length(Inputs, NumInputs),
+    functor(Head, Name, NumInputs),
+    term_variables(Head, TermList),
+    Body = (
+	lists:maplist(ffi:check_input, Inputs, TermList),
+	'$foreign_call'(Name, TermList, _),!
+    ),
+    Predicate =.. [:-, Head, Body],
+    assertz(ffi:Predicate).
+
+assert_predicate(PredicateDefinition) :-
+    PredicateDefinition =.. [Name, Inputs, bool],
+    length(Inputs, NumInputs),
+    functor(Head, Name, NumInputs),
+    term_variables(Head, TermList),
+    Body = (
+	lists:maplist(ffi:check_input, Inputs, TermList),
+	'$foreign_call'(Name, TermList, 1),!
+    ),
+    Predicate =.. [:-, Head, Body],
+    assertz(ffi:Predicate).
+
+assert_predicate(PredicateDefinition) :-
+    PredicateDefinition =.. [Name, Inputs, Return],
+    \+ member(Return, [void, bool]),
+    length(Inputs, NumInputs),
+    NumArgs is NumInputs + 1,
+    functor(Head, Name, NumArgs),
+    term_variables(Head, TermList),
+    Body = (
+	lists:append(TermListInputs, [TermListReturn], TermList),
+	lists:maplist(ffi:check_input, Inputs, TermListInputs),
+	'$foreign_call'(Name, TermListInputs, TermListReturn),!
+    ),
+    Predicate =.. [:-, Head, Body],
+    assertz(ffi:Predicate).
+
+check_input(sint8, Var) :-
+    must_be(integer, Var),
+    (
+	(Var > -129, Var < 128) ->
+	true
+    ;   domain_error(integer_does_not_fit, Var, foreign_call/3)
+    ).
+check_input(sint16, Var) :-
+    must_be(integer, Var),
+    (
+	(Var > -32769, Var < 32768) ->
+	true
+    ;   domain_error(integer_does_not_fit, Var, foreign_call/3)
+    ).
+check_input(sint32, Var) :-
+    must_be(integer, Var),
+    (
+	(Var > -2147483649, Var < 2147483648) ->
+	true
+    ;   domain_error(integer_does_not_fit, Var, foreign_call/3)
+    ).
+check_input(sint64, Var) :-
+    must_be(integer, Var).
+check_input(f32, _Var).
+check_input(f64, _Var).
+check_input(cstr, Var) :-
+    must_be(chars, Var).
+check_input(_, Var).
+%    must_be(list, Var).
+    
+% TODO: assert native predicates.
+% They MUST validate types

src/machine/dispatch.rs

@@ -4221,6 +4221,30 @@ impl Machine {
 		    try_or_throw!(self.machine_st, self.http_answer());
 		    step_or_fail!(self, self.machine_st.p = self.machine_st.cp);
 		}
+		&Instruction::CallLoadForeignLib(_) => {
+		    try_or_throw!(self.machine_st, self.load_foreign_lib());
+		    step_or_fail!(self, self.machine_st.p += 1);
+		}
+		&Instruction::ExecuteLoadForeignLib(_) => {
+		    try_or_throw!(self.machine_st, self.load_foreign_lib());
+		    step_or_fail!(self, self.machine_st.p = self.machine_st.cp);
+		}
+		&Instruction::CallForeignCall(_) => {
+		    try_or_throw!(self.machine_st, self.foreign_call());
+		    step_or_fail!(self, self.machine_st.p += 1);
+		}
+		&Instruction::ExecuteForeignCall(_) => {
+		    try_or_throw!(self.machine_st, self.foreign_call());
+		    step_or_fail!(self, self.machine_st.p = self.machine_st.cp);
+		}
+		&Instruction::CallDefineForeignStruct(_) => {
+		    try_or_throw!(self.machine_st, self.define_foreign_struct());
+		    step_or_fail!(self, self.machine_st.p += 1);
+		}
+		&Instruction::ExecuteDefineForeignStruct(_) => {
+		    try_or_throw!(self.machine_st, self.define_foreign_struct());
+		    step_or_fail!(self, self.machine_st.p = self.machine_st.cp);
+		}
                 &Instruction::CallCurrentTime(_) => {
                     self.current_time();
                     step_or_fail!(self, self.machine_st.p += 1);

src/machine/mock_wam.rs

@@ -236,7 +236,8 @@ impl Machine {
             user_output,
             user_error,
             load_contexts: vec![],
-            runtime
+            runtime,
+	    foreign_function_table: Default::default(),
         };
 
         let mut lib_path = current_dir();

src/machine/mod.rs

@@ -26,6 +26,7 @@ use crate::arena::*;
 use crate::arithmetic::*;
 use crate::atom_table::*;
 use crate::forms::*;
+use crate::ffi::ForeignFunctionTable;
 use crate::instructions::*;
 use crate::machine::args::*;
 use crate::machine::compile::*;
@@ -65,6 +66,7 @@ pub struct Machine {
     pub(super) user_error: Stream,
     pub(super) load_contexts: Vec<LoadContext>,
     pub(super) runtime: Runtime,
+    pub(super) foreign_function_table: ForeignFunctionTable, 
 }
 
 #[derive(Debug)]
@@ -443,6 +445,7 @@ impl Machine {
             user_error,
             load_contexts: vec![],
             runtime,
+	    foreign_function_table: Default::default(),
         };
 
         let mut lib_path = current_dir();

src/machine/system_calls.rs

@@ -6,6 +6,7 @@ use lazy_static::lazy_static;
 use crate::arena::*;
 use crate::atom_table::*;
 use crate::forms::*;
+use crate::ffi::*;
 use crate::heap_iter::*;
 use crate::heap_print::*;
 use crate::http::{self, HttpListener, HttpResponse};
@@ -40,6 +41,7 @@ use std::cmp::Ordering;
 use std::collections::BTreeSet;
 use std::convert::{TryFrom, Infallible};
 use std::env;
+use std::ffi::CString;
 use std::fs;
 use std::hash::{BuildHasher, BuildHasherDefault};
 use std::io::{ErrorKind, Read, Write};
@@ -4172,6 +4174,156 @@ impl Machine {
 	Ok(())
     }
 
+    #[inline(always)]
+    pub(crate) fn load_foreign_lib(&mut self) -> CallResult {
+	let library_name = self.deref_register(1);
+	let args_reg = self.deref_register(2);
+	if let Some(library_name) = self.machine_st.value_to_str_like(library_name) {
+	    let stub_gen = || functor_stub(atom!("use_foreign_module"), 2);
+	    match self.machine_st.try_from_list(args_reg, stub_gen) {
+		Ok(addrs) => {
+		    let mut functions = Vec::new();
+		    for heap_cell in addrs {
+			read_heap_cell!(heap_cell,
+			    (HeapCellValueTag::Str, s) => {
+			        let name = cell_as_atom_cell!(self.machine_st.heap[s]).get_name();
+				let args: Vec<Atom> = match self.machine_st.try_from_list(self.machine_st.heap[s + 1], stub_gen) {
+				    Ok(addrs) => {
+					let mut args = Vec::new();
+					for heap_cell in addrs {
+					    args.push(cell_as_atom_cell!(heap_cell).get_name());
+					}
+					args
+				    }
+				    Err(e) => return Err(e)
+				};
+				let return_value = cell_as_atom_cell!(self.machine_st.heap[s + 2]);
+				functions.push(FunctionDefinition {
+				    name: name.as_str().to_string(),
+				    args,
+				    return_value: return_value.get_name(),
+				});
+			    }
+			    _ => {
+			        unreachable!()
+		            }
+			)
+		    }
+		    if let Ok(_) = self.foreign_function_table.load_library(library_name.as_str(), &functions) {
+		        return Ok(());
+	            }
+		}
+		Err(e) => return Err(e)
+	    };
+	}
+	self.machine_st.fail = true;
+	Ok(())
+    }
+
+    #[inline(always)]
+    pub(crate) fn foreign_call(&mut self) -> CallResult {
+	let function_name = self.deref_register(1);
+	let args_reg = self.deref_register(2);
+	let return_value = self.deref_register(3);
+	if let Some(function_name) = self.machine_st.value_to_str_like(function_name) {
+   	    let stub_gen = || functor_stub(atom!("foreign_call"), 3);
+	    fn map_arg(mut machine_st: &mut MachineState, source: HeapCellValue) -> crate::ffi::Value {
+		match Number::try_from(source) {
+		    Ok(Number::Fixnum(n)) => {
+			Value::Int(n.get_num())
+		    },
+		    Ok(Number::Float(n)) => {
+			Value::Float(n.into_inner())
+		    },
+		    _ => {
+			let stub_gen = || functor_stub(atom!("foreign_call"), 3);
+			if let Some(string) = machine_st.value_to_str_like(source) {
+			    Value::CString(CString::new(string.as_str()).unwrap())
+			} else {
+			    match machine_st.try_from_list(source, stub_gen) {
+				Ok(args) => {
+				    let mut iter = args.into_iter();
+				    if let Some(struct_name) = machine_st.value_to_str_like(iter.next().unwrap()) {
+					Value::Struct(struct_name.as_str().to_string(), iter.map(|x| map_arg(&mut machine_st, x)).collect())
+				    } else {
+					unreachable!()
+				    }
+				}
+				_ => {
+				    unreachable!()
+				}
+			    }
+			}
+		    }
+		}
+	    }
+	    match self.machine_st.try_from_list(args_reg, stub_gen) {
+		Ok(args) => {
+		    let args: Vec<_> = args.into_iter().map(|x| map_arg(&mut self.machine_st, x)).collect();
+	    	    match self.foreign_function_table.exec(function_name.as_str(), args) {
+			Ok(result) => {
+			    match result {
+				Value::Int(n) => self.machine_st.unify_fixnum(Fixnum::build_with(n), return_value),
+				Value::Struct(name, mut args) => {
+				    args.insert(0, Value::CString(CString::new(name).unwrap()));
+				    let struct_list = heap_loc_as_cell!(
+					iter_to_heap_list(
+					    &mut self.machine_st.heap,
+					    args.into_iter()
+						.map(|val| {
+						    match val {
+							Value::Int(n) => fixnum_as_cell!(Fixnum::build_with(n)),
+							Value::CString(cstr) => atom_as_cell!(self.machine_st.atom_tbl.build_with(&cstr.into_string().unwrap())),
+							_ => unreachable!()
+						    }
+						}),
+					)
+				    );
+				    unify!(self.machine_st, return_value, struct_list);
+				}
+				_ => {
+				    unreachable!();
+				}
+			    }
+			    return Ok(());
+			},
+			Err(e) => {
+			    // throw error
+			    self.machine_st.fail = true;
+			    return Ok(());
+			}
+		    }
+		}
+		Err(e) => return Err(e)
+	    }
+	}
+	self.machine_st.fail = true;
+	Ok(())
+    }
+
+    #[inline(always)]
+    pub(crate) fn define_foreign_struct(&mut self) -> CallResult {
+	let struct_name = self.deref_register(1);
+	let fields_reg = self.deref_register(2);
+	if let Some(struct_name) = self.machine_st.value_to_str_like(struct_name) {
+	    let stub_gen = || functor_stub(atom!("define_foreign_struct"), 2);
+	    let fields: Vec<Atom> = match self.machine_st.try_from_list(fields_reg, stub_gen) {
+		Ok(addrs) => {
+		    let mut args = Vec::new();
+		    for heap_cell in addrs {
+			args.push(cell_as_atom_cell!(heap_cell).get_name());
+		    }
+		    args
+		}
+		Err(e) => return Err(e)
+	    };
+	    self.foreign_function_table.define_struct(struct_name.as_str(), fields);
+	    return Ok(())
+	}
+	self.machine_st.fail = true;
+	Ok(())
+    }
+
     #[inline(always)]
     pub(crate) fn current_time(&mut self) {
         let timestamp = self.systemtime_to_timestamp(SystemTime::now());