accept any and all characters in comment chars

diff --git a/Cargo.lock b/Cargo.lock
index 4db8d3930792eeff01e40229dd8661249824f11a..5c39e78db88df55e3cce3e06c69e2b9201af4a96 100644 (file)
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -511,9 +511,7 @@ dependencies = [
 
 [[package]]
 name = "prolog_parser"
-version = "0.8.54"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1724f289e6a670073445192ee382afd21138c106e2f4fa9797a7252926e7dea0"
+version = "0.8.55"
 dependencies = [
  "lexical",
  "num-rug-adapter",

diff --git a/Cargo.toml b/Cargo.toml
index 8cc5497a7fa869f47c40a55116fedf65bc8d8666..c26059fff4aceae0d8638b4b8a6bda4553cc3e2c 100644 (file)
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,7 @@ libc = "0.2.62"
 nix = "0.15.0"
 num-rug-adapter = { optional = true, version = "0.1.3" }
 ordered-float = "0.5.0"
-prolog_parser = { version = "0.8.54", default-features = false }
+prolog_parser = { version = "0.8.55", default-features = false }
 ref_thread_local = "0.0.0"
 rug = { version = "1.4.0", optional = true }
 rustyline = "6.0.0"

diff --git a/src/prolog/machine/compile.rs b/src/prolog/machine/compile.rs
index 636fc67c601a7aef8354c5d240944c5d1b484526..10bc4d229816fece72a3d3521926633e923eaa2a 100644 (file)
--- a/src/prolog/machine/compile.rs
+++ b/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,

diff --git a/src/prolog/machine/machine_state.rs b/src/prolog/machine/machine_state.rs
index 2194c3c1b54d06065ccc5b6be733a04f28a4aec5..8def9185ca9b92286f5d8c80af2a5031840d2a6a 100644 (file)
--- a/src/prolog/machine/machine_state.rs
+++ b/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,
                 ) {

diff --git a/src/prolog/machine/system_calls.rs b/src/prolog/machine/system_calls.rs
index a0e5762a7c6b31d47e3c54f809745e5d71d056aa..d393262695cea7d1ea48334a00ffbebd4f585849 100644 (file)
--- a/src/prolog/machine/system_calls.rs
+++ b/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,
                         ) {

diff --git a/src/prolog/machine/term_expansion.rs b/src/prolog/machine/term_expansion.rs
index d2b6419cc4d507654e75fc8ce61f7b2c0da86b4b..bb768219214b2d8a5a17a2146b248d2fc7447164 100644 (file)
--- a/src/prolog/machine/term_expansion.rs
+++ b/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!(