provide read_term_from_chars/2 (#334)

src/prolog/machine/machine_state.rs

@@ -1,4 +1,5 @@
 use prolog_parser::ast::*;
+use prolog_parser::tabled_rc::*;
 
 use crate::prolog::clause_types::*;
 use crate::prolog::forms::*;
@@ -11,6 +12,7 @@ use crate::prolog::machine::machine_indices::*;
 use crate::prolog::machine::modules::*;
 use crate::prolog::machine::stack::*;
 use crate::prolog::machine::streams::*;
+use crate::prolog::read::readline;
 use crate::prolog::rug::Integer;
 
 use downcast::Any;
@@ -492,6 +494,63 @@ pub struct MachineState {
 }
 
 impl MachineState {
+    pub(crate)
+    fn read_term(
+        &mut self,
+        current_input_stream: &mut Stream,
+        indices: &mut IndexStore,
+    ) -> CallResult {
+        match self.read(
+            &mut parsing_stream(current_input_stream.clone()),
+            indices.atom_tbl.clone(),
+            &indices.op_dir,
+        ) {
+            Ok(term_write_result) => {
+                let a1 = self[temp_v!(1)];
+                self.unify(Addr::HeapCell(term_write_result.heap_loc), a1);
+
+                if self.fail {
+                    return Ok(());
+                }
+
+                let mut list_of_var_eqs = vec![];
+
+                for (var, binding) in term_write_result.var_dict.into_iter().rev() {
+                    let var_atom = clause_name!(var.to_string(), indices.atom_tbl);
+
+                    let h = self.heap.h();
+                    let spec = fetch_atom_op_spec(clause_name!("="), None, &indices.op_dir);
+
+                    self.heap.push(HeapCellValue::NamedStr(2, clause_name!("="), spec));
+                    self.heap.push(HeapCellValue::Atom(var_atom, None));
+                    self.heap.push(HeapCellValue::Addr(binding));
+
+                    list_of_var_eqs.push(Addr::Str(h));
+                }
+
+                let a2 = self[temp_v!(2)];
+                let list_offset =
+                    Addr::HeapCell(self.heap.to_list(list_of_var_eqs.into_iter()));
+
+                Ok(self.unify(list_offset, a2))
+            }
+            Err(err) => {
+                if let ParserError::UnexpectedEOF = err {
+                    std::process::exit(0);
+                }
+
+                // reset the input stream after an input failure.
+                *current_input_stream = readline::input_stream();
+
+                let h = self.heap.h();
+                let syntax_error = MachineError::syntax_error(h, err);
+                let stub = MachineError::functor_stub(clause_name!("read_term"), 2);
+
+                Err(self.error_form(syntax_error, stub))
+            }
+        }
+    }
+
     pub(crate)
     fn write_term<'a>(
         &'a self,