From: Mark Thom <markjordanthom@gmail.com>
Date: Sun, 9 Sep 2018 01:46:34 +0000 (-0600)
Subject: read modifications
X-Git-Tag: v0.8.110~388
X-Git-Url: https://git.sagredo.dev/?a=commitdiff_plain;h=664f0f83dc8fdb11d48602258d2378f0b82d887b;p=scryer-prolog.git

read modifications
---

diff --git a/src/prolog/machine/machine_state.rs b/src/prolog/machine/machine_state.rs
index 6d85fd02..f2e05c7b 100644
--- a/src/prolog/machine/machine_state.rs
+++ b/src/prolog/machine/machine_state.rs
@@ -43,10 +43,6 @@ pub(crate) struct CodeDirs<'a> {
 }
 
 impl<'a> CodeDirs<'a> {
-    pub(super) fn new(code_dir: &'a CodeDir, op_dir: &'a OpDir, modules: &'a ModuleDir) -> Self {
-        CodeDirs { code_dir, op_dir, modules }
-    }
-
     fn get_internal(&self, name: ClauseName, arity: usize, in_mod: ClauseName) -> Option<ModuleCodeIndex> {
         self.modules.get(&in_mod)
             .and_then(|ref module| module.code_dir.get(&(name, arity)))
diff --git a/src/prolog/read.rs b/src/prolog/read.rs
index ffba2635..77629238 100644
--- a/src/prolog/read.rs
+++ b/src/prolog/read.rs
@@ -30,27 +30,49 @@ impl<'a> Reader<'a> {
         Reader { machine_st }
     }
 
-    pub fn read_stdin(&mut self, op_dir: &'a OpDir) -> Result<usize, ParserError> {
-        let mut buffer = String::new();
+    fn read_term(&self, buffer: &String, op_dir: &'a OpDir) -> Result<Term, ParserError>  {
+        let mut parser = Parser::new(buffer.as_bytes(), self.machine_st.atom_tbl.clone(),
+                                     self.machine_st.machine_flags());
 
+        parser.read_term(op_dir)
+    }
+    
+    fn read_term_loop(&mut self, buffer: &mut String, op_dir: &'a OpDir) -> Result<Term, ParserError> {
         let stdin = stdin();
-        let flags = self.machine_st.machine_flags();
-
+        
         loop {
-            let mut append_buf = String::new();
+            match self.read_term(&buffer, op_dir) {
+                Err(ParserError::UnexpectedEOF) => {},
+                result => return result
+            };
+             
+            let mut append_buf = String::new();            
             stdin.read_line(&mut append_buf).unwrap();
+            *buffer += append_buf.as_str();            
+        }
+    }
+/*    
+    pub fn repl_read(&mut self, op_dir: &'a OpDir) -> Result<Vec<Term>, ParserError> {
+        let mut buffer = String::new();
 
-            buffer += append_buf.as_str();
+        stdin().read_line(&mut buffer);
 
-            let mut parser = Parser::new(buffer.as_bytes(), self.machine_st.atom_tbl.clone(), flags);
+        if buffer.as_str() == "[user]" {
+            let locked = stdin().lock();
+            let mut parser = Parser::new(locked, self.machine_st.atom_tbl.clone(),
+                                         self.machine_st.flags());
 
-            match parser.read_term(op_dir) {
-                Err(ParserError::UnexpectedEOF) => continue,
-                Err(e) => return Err(e),
-                Ok(term) => return Ok(self.write_term_to_heap(term))
-            };
+            parser.read(op_dir)
+        } else {
+            Ok(vec![self.read_term_loop(buffer, op_dir)?])
         }
     }
+*/
+    pub fn read_stdin(&mut self, op_dir: &'a OpDir) -> Result<usize, ParserError>
+    {
+        let term = self.read_term_loop(&mut String::new(), op_dir)?;
+        Ok(self.write_term_to_heap(term))
+    }
 
     fn push_stub_addr(&mut self) {
         let h = self.machine_st.heap.h;