From a824a53fa8606dbc44e44da0ea4f305907300cee Mon Sep 17 00:00:00 2001 From: Mark Thom Date: Sat, 16 Jun 2018 23:36:22 -0600 Subject: [PATCH] prepare for updating the code_dir with each new predicate --- src/prolog/compile.rs | 25 ++++++++----- src/prolog/toplevel.rs | 83 ++++++++++++++++++++++++++++-------------- 2 files changed, 70 insertions(+), 38 deletions(-) diff --git a/src/prolog/compile.rs b/src/prolog/compile.rs index 38900c3c..9991ff63 100644 --- a/src/prolog/compile.rs +++ b/src/prolog/compile.rs @@ -88,10 +88,16 @@ impl TLInfo for QueryInfo { } } -pub fn parse_code(wam: &Machine, buffer: &str) -> Result +pub fn parse_code(wam: &mut Machine, buffer: &str) -> Result { - let mut worker = TopLevelWorker::new(buffer.as_bytes(), wam.atom_tbl()); - worker.parse_code(&wam.op_dir) + let atom_tbl = wam.atom_tbl(); + let index = MachineCodeIndex { + code_dir: &mut wam.code_dir, + op_dir: &mut wam.op_dir + }; + + let mut worker = TopLevelWorker::new(buffer.as_bytes(), atom_tbl, index); + worker.parse_code() } // throw errors if declaration or query found. @@ -220,13 +226,11 @@ pub fn compile_listing(wam: &mut Machine, src_str: &str) -> EvalSession let mut code = Vec::new(); - let mut worker = TopLevelWorker::new(src_str.as_bytes(), wam.atom_tbl()); - let tls = { - let indices = MachineCodeIndex { code_dir: &mut code_dir, - op_dir: &mut op_dir }; - - try_eval_session!(worker.parse_batch(&wam, indices)) + let indices = MachineCodeIndex { code_dir: &mut code_dir, op_dir: &mut op_dir }; + let mut worker = TopLevelWorker::new(src_str.as_bytes(), wam.atom_tbl(), indices); + + try_eval_session!(worker.parse_batch(&wam)) }; for tl in tls { @@ -255,7 +259,8 @@ pub fn compile_listing(wam: &mut Machine, src_str: &str) -> EvalSession wam.use_module_in_toplevel(name); }, - TopLevelPacket::Decl(TopLevel::Declaration(Declaration::UseQualifiedModule(name, exports)), _) + TopLevelPacket::Decl(TopLevel::Declaration(Declaration::UseQualifiedModule(name, exports)), + _) => { if let Some(ref submodule) = wam.get_module(name.clone()) { diff --git a/src/prolog/toplevel.rs b/src/prolog/toplevel.rs index cfb5c0e2..5b8f763a 100644 --- a/src/prolog/toplevel.rs +++ b/src/prolog/toplevel.rs @@ -5,7 +5,7 @@ use prolog::parser::parser::*; use prolog::tabled_rc::*; use std::collections::{HashSet, VecDeque}; -use std::cell::Cell; +use std::cell::{Cell, RefCell}; use std::io::Read; use std::mem; use std::rc::Rc; @@ -164,7 +164,7 @@ fn is_consistent(tl: &TopLevel, clauses: &Vec) -> bool } } -pub fn deque_to_packet(head: TopLevel, deque: VecDeque) -> TopLevelPacket +fn deque_to_packet(head: TopLevel, deque: VecDeque) -> TopLevelPacket { match head { TopLevel::Query(query) => TopLevelPacket::Query(query, Vec::from(deque)), @@ -172,7 +172,7 @@ pub fn deque_to_packet(head: TopLevel, deque: VecDeque) -> TopLevelPac } } -pub fn merge_clauses(tls: &mut VecDeque) -> Result +fn merge_clauses(tls: &mut VecDeque) -> Result { let mut clauses: Vec = vec![]; @@ -212,6 +212,11 @@ pub fn merge_clauses(tls: &mut VecDeque) -> Result) -> TopLevel { + let preds = mem::replace(preds, vec![]); + TopLevel::Predicate(Predicate(preds)) +} + fn unfold_by_str_once(term: &mut Term, s: &str) -> Option<(Term, Term)> { if let &mut Term::Clause(_, ref name, ref mut subterms, _) = term { @@ -507,8 +512,7 @@ impl RelationWorker { } } - - pub fn try_term_to_tl(&mut self, term: Term, blocks_cuts: bool) -> Result + fn try_term_to_tl(&mut self, term: Term, blocks_cuts: bool) -> Result { match term { Term::Clause(r, name, mut terms, fixity) => @@ -556,31 +560,51 @@ impl RelationWorker { } } -pub struct TopLevelWorker where R: Read { - pub parser: Parser +pub struct TopLevelWorker<'a, R> where R: Read { + pub parser: Parser, + indices: MachineCodeIndex<'a> } -impl TopLevelWorker { - pub fn new(inner: R, atom_tbl: TabledData) -> Self { - TopLevelWorker { parser: Parser::new(inner, atom_tbl) } +impl<'a, R: Read> TopLevelWorker<'a, R> { + pub fn new(inner: R, atom_tbl: TabledData, indices: MachineCodeIndex<'a>) -> Self { + TopLevelWorker { parser: Parser::new(inner, atom_tbl), indices } } - pub fn parse_batch<'a>(&mut self, wam: &Machine, mut indices: MachineCodeIndex<'a>) - -> Result, SessionError> + fn add_predicate(&mut self, name: ClauseName, mod_name: ClauseName, tl: TopLevel) + -> Vec { - let mut preds = vec![]; - let mut mod_name = clause_name!("user"); - let mut results = vec![]; - let mut rel_worker = RelationWorker::new(); - - fn append_preds(preds: &mut Vec) -> TopLevel { - let preds = mem::replace(preds, vec![]); - TopLevel::Predicate(Predicate(preds)) + let add_name = move |arity| { + let idx = CodeIndex(Rc::new(RefCell::new((IndexPtr::Undefined, mod_name)))); + self.indices.code_dir.insert((name, arity), idx); + }; + + match tl { + TopLevel::Rule(rule) => { + add_name(rule.head.1.len()); + vec![PredicateClause::Rule(rule)] + }, + TopLevel::Fact(fact) => { + add_name(fact.arity()); + vec![PredicateClause::Fact(fact)] + }, + TopLevel::Predicate(preds) => { + add_name(preds.0.len()); + preds.0 + }, + _ => vec![] } + } + + pub fn parse_batch(&mut self, wam: &Machine) -> Result, SessionError> + { + let mut preds = vec![]; + let mut results = vec![]; + let mut mod_name = clause_name!("user"); + let mut rel_worker = RelationWorker::new(); while !self.parser.eof() { self.parser.reset(); // empty the parser stack of token descriptions. - let term = self.parser.read_term(&indices.op_dir)?; + let term = self.parser.read_term(&self.indices.op_dir)?; let mut new_rel_worker = RelationWorker::new(); let tl = new_rel_worker.try_term_to_tl(term, true)?; @@ -590,24 +614,27 @@ impl TopLevelWorker { } rel_worker.absorb(new_rel_worker); - + match tl { TopLevel::Declaration(Declaration::UseModule(name)) => if let Some(module) = wam.get_module(name) { - indices.use_module(module); + self.indices.use_module(module); }, TopLevel::Declaration(Declaration::Op(op_decl)) => { - op_decl.submit(mod_name.clone(), indices.op_dir)?; + op_decl.submit(mod_name.clone(), self.indices.op_dir)?; }, TopLevel::Declaration(Declaration::Module(actual_mod)) => { - mod_name = actual_mod.name.clone(); + mod_name = actual_mod.name.clone(); let tl = TopLevel::Declaration(Declaration::Module(actual_mod)); results.push(TopLevelPacket::Decl(tl, vec![])); }, TopLevel::Declaration(decl) => { results.push(TopLevelPacket::Decl(TopLevel::Declaration(decl), vec![])); }, - tl => preds.extend(tl.as_predicate().ok().unwrap().clauses().into_iter()) + tl => match tl.name() { + Some(name) => preds.extend(self.add_predicate(name, mod_name.clone(), tl)), + _ => return Err(SessionError::NamelessEntry) + } }; } @@ -618,11 +645,11 @@ impl TopLevelWorker { Ok(results) } - pub fn parse_code(&mut self, op_dir: &OpDir) -> Result + pub fn parse_code(&mut self) -> Result { let mut rel_worker = RelationWorker::new(); - let terms = self.parser.read(op_dir)?; + let terms = self.parser.read(self.indices.op_dir)?; let mut tls = rel_worker.try_terms_to_tls(terms, true)?; let results = rel_worker.parse_queue()?; -- 2.54.0