From 46b695d093615f3e856becca84bbd518e841fae3 Mon Sep 17 00:00:00 2001 From: Mark Thom Date: Fri, 1 May 2020 16:39:27 -0600 Subject: [PATCH] accept any and all characters in comment chars --- Cargo.lock | 4 +-- Cargo.toml | 2 +- src/prolog/machine/compile.rs | 15 ++++++---- src/prolog/machine/machine_state.rs | 41 ++++++++++++++++++++++++++-- src/prolog/machine/system_calls.rs | 38 ++++++++++++++++++++++---- src/prolog/machine/term_expansion.rs | 2 +- 6 files changed, 84 insertions(+), 18 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 4db8d393..5c39e78d 100644 --- 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 8cc5497a..c26059ff 100644 --- 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 636fc67c..10bc4d22 100644 --- 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 2194c3c1..8def9185 100644 --- 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 { + 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 a0e5762a..d3932626 100644 --- 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 d2b6419c..bb768219 100644 --- 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 { - 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!( -- 2.54.0