accept any and all characters in comment chars

src/prolog/machine/compile.rs

@@ -77,9 +77,11 @@ fn load_module(
         listing_src.clone(),
     );
 
+    let mut stream = parsing_stream(stream)?;
+
     let results = compiler.gather_items(
         wam,
-        &mut parsing_stream(stream),
+        &mut stream,
         &mut indices,
     );
 
@@ -373,9 +375,11 @@ fn compile_into_module_impl(
     wam.code_repo.compile_hook(CompileTimeHook::TermExpansion)?;
     wam.code_repo.compile_hook(CompileTimeHook::GoalExpansion)?;
 
+    let mut stream = parsing_stream(src)?;
+
     let mut results = compiler.gather_items(
         wam,
-        &mut parsing_stream(src),
+        &mut stream,
         &mut indices,
     )?;
 
@@ -1357,7 +1361,8 @@ fn compile_work(
     src: Stream,
     mut indices: IndexStore,
 ) -> EvalSession {
-    let src = &mut parsing_stream(src);
+    let mut stream = try_eval_session!(parsing_stream(src));
+    let src = &mut stream;
     let results = try_eval_session!(compiler.gather_items(wam, src, &mut indices));
 
     try_eval_session!(compile_work_impl(compiler, wam, indices, results));
@@ -1376,9 +1381,9 @@ pub fn compile_special_form(
     let mut indices = default_index_store!(wam.indices.atom_tbl.clone());
     setup_indices(wam, clause_name!("builtins"), &mut indices)?;
 
-    let src = &mut parsing_stream(src);
+    let mut src = parsing_stream(src)?;
     let mut compiler = ListingCompiler::new(&wam.code_repo, true, listing_src);
-    let mut results = compiler.gather_items(wam, src, &mut indices)?;
+    let mut results = compiler.gather_items(wam, &mut src, &mut indices)?;
 
     compiler.adapt_in_situ_code(
         results.worker_results,

src/prolog/machine/machine_state.rs

@@ -12,7 +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::read::{PrologStream, readline};
 use crate::prolog::rug::Integer;
 
 use downcast::Any;
@@ -610,14 +610,43 @@ pub struct MachineState {
 }
 
 impl MachineState {
+    pub(crate)
+    fn open_parsing_stream(
+        &self,
+        stream: Stream,
+        stub_name: &'static str,
+        stub_arity: usize,
+    ) -> Result<PrologStream, MachineStub> {
+        match parsing_stream(stream) {
+            Ok(stream) => {
+                Ok(stream)
+            }
+            Err(e) => {
+                let stub = MachineError::functor_stub(clause_name!(stub_name), stub_arity);
+                let err = MachineError::session_error(
+                    self.heap.h(),
+                    SessionError::from(e),
+                );
+
+                Err(self.error_form(err, stub))
+            }
+        }
+    }
+
     pub(crate)
     fn read_term(
         &mut self,
         current_input_stream: &mut Stream,
         indices: &mut IndexStore,
     ) -> CallResult {
+        let mut stream = self.open_parsing_stream(
+            current_input_stream.clone(),
+            "read_term",
+            2,
+        )?;
+
         match self.read(
-            &mut parsing_stream(current_input_stream.clone()),
+            &mut stream,
             indices.atom_tbl.clone(),
             &indices.op_dir,
         ) {
@@ -1257,8 +1286,14 @@ pub(crate) trait CallPolicy: Any + fmt::Debug {
                 return_from_clause!(machine_st.last_call, machine_st)
             }
             &BuiltInClauseType::Read => {
+                let mut stream = machine_st.open_parsing_stream(
+                    current_input_stream.clone(),
+                    "read",
+                    1,
+                )?;
+
                 match machine_st.read(
-                    &mut parsing_stream(current_input_stream.clone()),
+                    &mut stream,
                     indices.atom_tbl.clone(),
                     &indices.op_dir,
                 ) {

src/prolog/machine/system_calls.rs

@@ -595,8 +595,26 @@ impl MachineState {
 
         string.push('.');
 
-        let mut stream = parsing_stream(std::io::Cursor::new(string));
-        let mut parser = Parser::new(&mut stream, indices.atom_tbl.clone(), self.machine_flags());
+        let mut stream =
+            match parsing_stream(std::io::Cursor::new(string)) {
+                Ok(stream) => {
+                    stream
+                }
+                Err(e) => {
+                    let err = MachineError::session_error(
+                        self.heap.h(),
+                        SessionError::from(e),
+                    );
+
+                    return Err(self.error_form(err, stub));
+                }
+            };
+
+        let mut parser = Parser::new(
+            &mut stream,
+            indices.atom_tbl.clone(),
+            self.machine_flags(),
+        );
 
         match parser.read_term(composite_op!(&indices.op_dir)) {
             Err(err) => {
@@ -1603,9 +1621,13 @@ impl MachineState {
                 self.unify(char_list, a2);
             }
             &SystemClauseType::GetChar => {
-                let mut iter = parsing_stream(current_input_stream.clone());
-                let result = iter.next();
+                let mut iter = self.open_parsing_stream(
+                    current_input_stream.clone(),
+                    "get_char",
+                    1,
+                )?;
 
+                let result = iter.next();
                 let a1 = self[temp_v!(1)];
 
                 match result {
@@ -3173,10 +3195,16 @@ impl MachineState {
                 let mut heap_pstr_iter = self.heap_pstr_iter(self[temp_v!(1)]);
                 let chars = heap_pstr_iter.to_string();
 
+                let mut stream = self.open_parsing_stream(
+                    Stream::from(chars),
+                    "read_term_from_chars",
+                    2,
+                )?;
+
                 if let Addr::EmptyList = heap_pstr_iter.focus() {
                     let term_write_result =
                         match self.read(
-                            &mut parsing_stream(Stream::from(chars)),
+                            &mut stream,
                             indices.atom_tbl.clone(),
                             &indices.op_dir,
                         ) {

src/prolog/machine/term_expansion.rs

@@ -221,7 +221,7 @@ impl<'a> TermStream<'a> {
         term_string: &str,
         op_dir: &OpDir,
     ) -> Result<Term, ParserError> {
-        let mut stream = parsing_stream(term_string.trim().as_bytes());
+        let mut stream = parsing_stream(term_string.trim().as_bytes())?;
         let mut parser = Parser::new(&mut stream, self.parser.get_atom_tbl(), self.flags);
 
         parser.read_term(composite_op!(