rishi/scryer-prolog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

get rid of LocalMachineCodeIndex

Browse Source
This commit is contained in:
Mark Thom
2018-06-24 23:32:50 -06:00
parent 2d7032e61a
commit 870316b0d1
6 changed files with 54 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
src/prolog/ast.rs
View File

@@ -167,8 +167,8 @@ pub fn default_op_dir() -> OpDir {
let mut op_dir = OpDir::new();
op_dir.insert((clause_name!(":-"), Fixity::In), (XFX, 1200, module_name.clone()));
op_dir.insert((clause_name!(":-"), Fixity::Pre), (FX, 1200, module_name.clone()));
op_dir.insert((clause_name!("?-"), Fixity::Pre), (FX, 1200, module_name.clone()));
op_dir.insert((clause_name!(":-"), Fixity::Pre), (FX, 1200, module_name.clone()));
op_dir.insert((clause_name!("?-"), Fixity::Pre), (FX, 1200, module_name.clone()));
op_dir
}
@@ -588,7 +588,7 @@ impl InlinedClauseType {
&InlinedClauseType::IsVar(..) => "var"
}
}
pub fn from(name: &str, arity: usize) -> Option<Self> {
let r1 = temp_v!(1);
let r2 = temp_v!(2);
@@ -976,18 +976,6 @@ impl ClauseType {
}
}
/*
pub fn lookup(wam: &Machine, name: ClauseName, arity: usize, fixity: Option<Fixity>) -> Self {
match ClauseType::from(name, arity, fixity) {
ClauseType::Named(name, default_idx) => {
},
ClauseType::Op(name, fixity, default_idx) => {
},
ct => ct
}
}
*/
pub fn from(name: ClauseName, arity: usize, fixity: Option<Fixity>) -> Self {
InlinedClauseType::from(name.as_str(), arity)
.map(ClauseType::Inlined)
@@ -1603,7 +1591,7 @@ pub struct CodeIndex(pub Rc<RefCell<(IndexPtr, ClauseName)>>);
impl CodeIndex {
pub fn is_undefined(&self) -> bool {
let index_ptr = self.0.borrow().0;
if let IndexPtr::Undefined = index_ptr {
true
} else {

102
src/prolog/compile.rs
View File

@@ -32,70 +32,15 @@ fn print_code(code: &Code) {
}
}
pub(crate) trait TLInfo {
fn update_entry_index(&self, &ClauseName, usize, CodeIndex, &mut CodeIndex, usize);
// give the correct CodePtr offsets to CallClause's whose types are
// Named and Op. Enable late binding by setting to the default.
fn label_clauses(&self, code_size: usize, code_dir: &mut CodeDir, code: &mut Code)
{
for line in code.iter_mut() {
if let &mut Line::Control(ControlInstruction::CallClause(ref mut ct, a1, ..)) = line {
match ct {
&mut ClauseType::Named(ref n1, ref mut cp)
| &mut ClauseType::Op(ref n1, _, ref mut cp) => {
let entry = code_dir.entry((n1.clone(), a1)).or_insert(CodeIndex::default());
self.update_entry_index(n1, a1, entry.clone(), cp, code_size);
},
_ => {}
}
}
}
}
}
struct DeclInfo { name: ClauseName, arity: usize, module_name: ClauseName }
impl TLInfo for DeclInfo {
fn update_entry_index(&self, n1: &ClauseName, a1: usize, entry: CodeIndex,
cp: &mut CodeIndex, code_size: usize)
{
let (name, arity) = (self.name.clone(), self.arity);
{
let mut entry = entry.0.borrow_mut();
if entry.0 == IndexPtr::Undefined {
if &name == n1 && arity == a1 {
entry.0 = IndexPtr::Index(code_size);
}
}
entry.1 = self.module_name.clone();
}
*cp = entry;
}
}
struct QueryInfo {}
impl TLInfo for QueryInfo {
fn update_entry_index(&self, _: &ClauseName, _: usize, entry: CodeIndex,
cp: &mut CodeIndex, _: usize)
{
*cp = entry;
}
}
pub fn parse_code(wam: &mut Machine, buffer: &str) -> Result<TopLevelPacket, ParserError>
{
let atom_tbl = wam.atom_tbl();
let atom_tbl = wam.atom_tbl();
let index = MachineCodeIndex {
code_dir: &mut wam.code_dir,
op_dir: &mut wam.op_dir
op_dir: &mut wam.op_dir,
modules: &wam.modules
};
let mut worker = TopLevelWorker::new(buffer.as_bytes(), atom_tbl, index);
worker.parse_code()
}
@@ -145,18 +90,13 @@ fn compile_appendix(code: &mut Code, queue: Vec<TopLevel>) -> Result<(), ParserE
Ok(())
}
fn compile_query(terms: Vec<QueryTerm>, queue: Vec<TopLevel>, code_size: usize,
code_dir: &mut CodeDir)
-> Result<(Code, AllocVarDict), ParserError>
fn compile_query(terms: Vec<QueryTerm>, queue: Vec<TopLevel>) -> Result<(Code, AllocVarDict), ParserError>
{
let mut cg = CodeGenerator::<DebrayAllocator>::new();
let mut code = try!(cg.compile_query(&terms));
compile_appendix(&mut code, queue)?;
let query_info = QueryInfo {};
query_info.label_clauses(code_size, code_dir, &mut code);
Ok((code, cg.take_vars()))
}
@@ -183,11 +123,6 @@ fn compile_decl(wam: &mut Machine, tl: TopLevel, queue: Vec<TopLevel>) -> EvalSe
let mut code = try_eval_session!(compile_relation(&tl));
try_eval_session!(compile_appendix(&mut code, queue));
let decl_info = DeclInfo { name: name.clone(), arity: tl.arity(),
module_name: clause_name!("user") };
decl_info.label_clauses(wam.code_size(), &mut wam.code_dir, &mut code);
if !code.is_empty() {
wam.add_user_code(name, tl.arity(), code, tl.as_predicate().ok().unwrap())
} else {
@@ -201,7 +136,7 @@ pub fn compile_packet(wam: &mut Machine, tl: TopLevelPacket) -> EvalSession
{
match tl {
TopLevelPacket::Query(terms, queue) =>
match compile_query(terms, queue, wam.code_size(), &mut wam.code_dir) {
match compile_query(terms, queue) { //, &mut wam.code_dir) { //wam.code_size(), &mut wam.code_dir) {
Ok((mut code, vars)) => wam.submit_query(code, vars),
Err(e) => EvalSession::from(e)
},
@@ -227,10 +162,10 @@ pub fn compile_listing(wam: &mut Machine, src_str: &str) -> EvalSession
let mut code = Vec::new();
let tls = {
let indices = MachineCodeIndex { code_dir: &mut code_dir, op_dir: &mut op_dir };
let indices = machine_code_index!(&mut code_dir, &mut op_dir, &wam.modules);
let mut worker = TopLevelWorker::new(src_str.as_bytes(), wam.atom_tbl(), indices);
try_eval_session!(worker.parse_batch(&wam))
try_eval_session!(worker.parse_batch())
};
for tl in tls {
@@ -246,7 +181,7 @@ pub fn compile_listing(wam: &mut Machine, src_str: &str) -> EvalSession
TopLevelPacket::Decl(TopLevel::Declaration(Declaration::UseModule(name)), _) => {
if let Some(ref submodule) = wam.get_module(name.clone()) {
if let Some(ref mut module) = module {
let mut code_index = machine_code_index!(&mut code_dir, &mut op_dir);
let mut code_index = machine_code_index!(&mut code_dir, &mut op_dir, &wam.modules);
module.use_module(submodule);
code_index.use_module(submodule);
@@ -259,13 +194,12 @@ 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()) {
if let Some(ref mut module) = module {
let mut code_index = machine_code_index!(&mut code_dir, &mut op_dir);
let mut code_index = machine_code_index!(&mut code_dir, &mut op_dir, &wam.modules);
module.use_qualified_module(submodule, &exports);
code_index.use_qualified_module(submodule, &exports);
@@ -291,18 +225,10 @@ pub fn compile_listing(wam: &mut Machine, src_str: &str) -> EvalSession
Err(SessionError::NamelessEntry)
});
let module_name = get_module_name(&module);
let decl_info = DeclInfo { name, arity: decl.arity(),
module_name: module_name.clone() };
{
let idx = code_dir.entry((decl_info.name.clone(), decl_info.arity))
.or_insert(CodeIndex::default());
set_code_index!(idx, IndexPtr::Index(p), module_name);
if let Some(ref mut idx) = code_dir.get_mut(&(name, decl.arity())) {
set_code_index!(idx, IndexPtr::Index(p), get_module_name(&module));
}
decl_info.label_clauses(p, &mut code_dir, &mut decl_code);
code.extend(decl_code.into_iter());
}
}

6
src/prolog/macros.rs
View File

@@ -140,7 +140,7 @@ macro_rules! call_clause {
);
($ct:expr, $arity:expr, $pvs:expr, $lco:expr) => (
Line::Control(ControlInstruction::CallClause($ct, $arity, $pvs, $lco))
)
)
}
macro_rules! proceed {
@@ -234,8 +234,8 @@ macro_rules! set_code_index {
}
macro_rules! machine_code_index {
($code_dir:expr, $op_dir:expr) => (
MachineCodeIndex { code_dir: $code_dir, op_dir: $op_dir }
($code_dir:expr, $op_dir:expr, $modules:expr) => (
MachineCodeIndex { code_dir: $code_dir, op_dir: $op_dir, modules: $modules }
)
}

2
src/prolog/mod.rs
View File

@@ -9,6 +9,7 @@ pub mod ast;
#[macro_use]
pub mod allocator;
pub mod toplevel;
pub mod machine;
pub mod compile;
pub mod arithmetic;
pub mod codegen;
@@ -20,7 +21,6 @@ pub mod heap_print;
pub mod indexing;
pub mod io;
pub mod iterators;
pub mod machine;
pub mod or_stack;
#[macro_use]
pub mod parser;

67
src/prolog/toplevel.rs
View File

@@ -5,7 +5,7 @@ use prolog::parser::parser::*;
use prolog::tabled_rc::*;
use std::collections::{HashSet, VecDeque};
use std::cell::{Cell, RefCell};
use std::cell::Cell;
use std::io::Read;
use std::mem;
use std::rc::Rc;
@@ -392,14 +392,15 @@ impl RelationWorker {
self.fabricate_rule(fold_by_str(prec_seq, body_term, comma_sym))
}
fn to_query_term(&mut self, term: Term) -> Result<QueryTerm, ParserError>
fn to_query_term(&mut self, indices: &mut MachineCodeIndex, term: Term) -> Result<QueryTerm, ParserError>
{
match term {
Term::Constant(r, Constant::Atom(name)) =>
if name.as_str() == "!" || name.as_str() == "blocked_!" {
Ok(QueryTerm::BlockedCut)
} else {
Ok(QueryTerm::Clause(r, ClauseType::from(name, 0, None), vec![]))
let ct = ClauseType::lookup(indices, name, 0, None);
Ok(QueryTerm::Clause(r, ct, vec![]))
},
Term::Var(_, ref v) if v.as_str() == "!" =>
Ok(QueryTerm::UnblockedCut(Cell::default())),
@@ -425,9 +426,8 @@ impl RelationWorker {
Err(ParserError::InadmissibleQueryTerm)
}
} else {
Ok(QueryTerm::Clause(Cell::default(),
ClauseType::from(name, terms.len(), fixity),
terms))
let ct = ClauseType::lookup(indices, name, terms.len(), fixity);
Ok(QueryTerm::Clause(Cell::default(), ct, terms))
},
Term::Var(_, _) =>
Ok(QueryTerm::Clause(Cell::default(), ClauseType::CallN, vec![Box::new(term)])),
@@ -460,7 +460,7 @@ impl RelationWorker {
}
}
fn setup_query(&mut self, terms: Vec<Box<Term>>, blocks_cuts: bool)
fn setup_query(&mut self, idx: &mut MachineCodeIndex, terms: Vec<Box<Term>>, blocks_cuts: bool)
-> Result<Vec<QueryTerm>, ParserError>
{
let mut query_terms = vec![];
@@ -488,18 +488,18 @@ impl RelationWorker {
mark_cut_variable(&mut subterm);
}
query_terms.push(try!(self.to_query_term(subterm)));
query_terms.push(try!(self.to_query_term(idx, subterm)));
}
}
Ok(query_terms)
}
fn setup_rule(&mut self, mut terms: Vec<Box<Term>>, blocks_cuts: bool)
fn setup_rule(&mut self, idx: &mut MachineCodeIndex, mut terms: Vec<Box<Term>>, blocks_cuts: bool)
-> Result<Rule, ParserError>
{
let post_head_terms = terms.drain(1..).collect();
let mut query_terms = try!(self.setup_query(post_head_terms, blocks_cuts));
let mut query_terms = try!(self.setup_query(idx, post_head_terms, blocks_cuts));
let clauses = query_terms.drain(1 ..).collect();
let qt = query_terms.pop().unwrap();
@@ -512,14 +512,15 @@ impl RelationWorker {
}
}
fn try_term_to_tl(&mut self, term: Term, blocks_cuts: bool) -> Result<TopLevel, ParserError>
fn try_term_to_tl(&mut self, idx: &mut MachineCodeIndex, term: Term, blocks_cuts: bool)
-> Result<TopLevel, ParserError>
{
match term {
Term::Clause(r, name, mut terms, fixity) =>
if name.as_str() == "?-" {
Ok(TopLevel::Query(try!(self.setup_query(terms, blocks_cuts))))
Ok(TopLevel::Query(try!(self.setup_query(idx, terms, blocks_cuts))))
} else if name.as_str() == ":-" && terms.len() > 1 {
Ok(TopLevel::Rule(try!(self.setup_rule(terms, blocks_cuts))))
Ok(TopLevel::Rule(try!(self.setup_rule(idx, terms, blocks_cuts))))
} else if name.as_str() == ":-" && terms.len() == 1 {
let term = *terms.pop().unwrap();
Ok(TopLevel::Declaration(try!(setup_declaration(term))))
@@ -530,25 +531,25 @@ impl RelationWorker {
}
}
fn try_terms_to_tls<Iter>(&mut self, terms: Iter, blocks_cuts: bool)
fn try_terms_to_tls<Iter>(&mut self, idx: &mut MachineCodeIndex, terms: Iter, blocks_cuts: bool)
-> Result<VecDeque<TopLevel>, ParserError>
where Iter: IntoIterator<Item=Term>
{
let mut results = VecDeque::new();
for term in terms.into_iter() {
results.push_back(self.try_term_to_tl(term, blocks_cuts)?);
results.push_back(self.try_term_to_tl(idx, term, blocks_cuts)?);
}
Ok(results)
}
fn parse_queue(&mut self) -> Result<VecDeque<TopLevel>, ParserError>
fn parse_queue(&mut self, idx: &mut MachineCodeIndex) -> Result<VecDeque<TopLevel>, ParserError>
{
let mut queue = VecDeque::new();
while let Some(terms) = self.queue.pop_front() {
let clauses = merge_clauses(&mut self.try_terms_to_tls(terms, false)?)?;
let clauses = merge_clauses(&mut self.try_terms_to_tls(idx, terms, false)?)?;
queue.push_back(clauses);
}
@@ -570,15 +571,6 @@ impl<'a, R: Read> TopLevelWorker<'a, R> {
TopLevelWorker { parser: Parser::new(inner, atom_tbl), indices }
}
fn add_name(&mut self, pred: &PredicateClause, mod_name: ClauseName) -> Option<ClauseName> {
pred.name().and_then(move |name| {
let idx = CodeIndex(Rc::new(RefCell::new((IndexPtr::Undefined, mod_name))));
self.indices.code_dir.insert((name.clone(), pred.arity()), idx);
Some(name)
})
}
fn add_predicate(&mut self, tl: TopLevel) -> Vec<PredicateClause>
{
match tl {
@@ -589,7 +581,7 @@ impl<'a, R: Read> TopLevelWorker<'a, R> {
}
}
pub fn parse_batch(&mut self, wam: &Machine) -> Result<Vec<TopLevelPacket>, SessionError>
pub fn parse_batch(&mut self) -> Result<Vec<TopLevelPacket>, SessionError>
{
let mut preds = vec![];
let mut results = vec![];
@@ -600,26 +592,26 @@ impl<'a, R: Read> TopLevelWorker<'a, R> {
self.parser.reset(); // empty the parser stack of token descriptions.
let term = self.parser.read_term(&self.indices.op_dir)?;
let mut new_rel_worker = RelationWorker::new(); //wam, mod_name.clone());
let tl = new_rel_worker.try_term_to_tl(term, true)?;
let mut new_rel_worker = RelationWorker::new();
let tl = new_rel_worker.try_term_to_tl(&mut self.indices, term, true)?;
if !is_consistent(&tl, &preds) { // if is_consistent returns false, preds is non-empty.
preds.first().map(|pred| self.add_name(pred, mod_name.clone()));
results.push(deque_to_packet(append_preds(&mut preds), rel_worker.parse_queue()?));
let result_queue = rel_worker.parse_queue(&mut self.indices)?;
results.push(deque_to_packet(append_preds(&mut preds), result_queue));
}
rel_worker.absorb(new_rel_worker);
match tl {
TopLevel::Declaration(Declaration::UseModule(name)) =>
if let Some(module) = wam.get_module(name) {
if let Some(module) = self.indices.modules.get(&name) {
self.indices.use_module(module);
},
TopLevel::Declaration(Declaration::Op(op_decl)) => {
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![]));
},
@@ -635,7 +627,8 @@ impl<'a, R: Read> TopLevelWorker<'a, R> {
}
if !preds.is_empty() {
results.push(deque_to_packet(append_preds(&mut preds), rel_worker.parse_queue()?));
results.push(deque_to_packet(append_preds(&mut preds),
rel_worker.parse_queue(&mut self.indices)?));
}
Ok(results)
@@ -643,11 +636,11 @@ impl<'a, R: Read> TopLevelWorker<'a, R> {
pub fn parse_code(&mut self) -> Result<TopLevelPacket, ParserError>
{
let mut rel_worker = RelationWorker::new(); //wam, clause_name!("user"));
let mut rel_worker = RelationWorker::new();
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()?;
let mut tls = rel_worker.try_terms_to_tls(&mut self.indices, terms, true)?;
let results = rel_worker.parse_queue(&mut self.indices)?;
let tl = merge_clauses(&mut tls)?;