MVP of Foreign Function Interface

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());