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

complete trimdown of listing compilation.

Browse Source
This commit is contained in:
Mark Thom
2018-07-01 18:14:45 -06:00
parent fc11fda947
commit 0abd075b0b
9 changed files with 227 additions and 300 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/prolog/ast.rs
View File

@@ -810,8 +810,8 @@ pub enum ClauseType {
BuiltIn(BuiltInClauseType),
CallN,
Inlined(InlinedClauseType),
Op(ClauseName, Fixity, CodeIndex),
Named(ClauseName, CodeIndex),
Op(ClauseName, Fixity, CodeIndex),
System(SystemClauseType)
}
@@ -1121,54 +1121,6 @@ impl Number {
&Number::Rational(ref r) => r.is_zero()
}
}
pub fn gt(self, n2: Number) -> bool {
match NumberPair::from(self, n2) {
NumberPair::Integer(n1, n2) => n1 > n2,
NumberPair::Float(n1, n2) => n1 > n2,
NumberPair::Rational(n1, n2) => n1 > n2
}
}
pub fn gte(self, n2: Number) -> bool {
match NumberPair::from(self, n2) {
NumberPair::Integer(n1, n2) => n1 >= n2,
NumberPair::Float(n1, n2) => n1 >= n2,
NumberPair::Rational(n1, n2) => n1 >= n2
}
}
pub fn lt(self, n2: Number) -> bool {
match NumberPair::from(self, n2) {
NumberPair::Integer(n1, n2) => n1 < n2,
NumberPair::Float(n1, n2) => n1 < n2,
NumberPair::Rational(n1, n2) => n1 < n2
}
}
pub fn lte(self, n2: Number) -> bool {
match NumberPair::from(self, n2) {
NumberPair::Integer(n1, n2) => n1 <= n2,
NumberPair::Float(n1, n2) => n1 <= n2,
NumberPair::Rational(n1, n2) => n1 <= n2
}
}
pub fn ne(self, n2: Number) -> bool {
match NumberPair::from(self, n2) {
NumberPair::Integer(n1, n2) => n1 != n2,
NumberPair::Float(n1, n2) => n1 != n2,
NumberPair::Rational(n1, n2) => n1 != n2
}
}
pub fn eq(self, n2: Number) -> bool {
match NumberPair::from(self, n2) {
NumberPair::Integer(n1, n2) => n1 == n2,
NumberPair::Float(n1, n2) => n1 == n2,
NumberPair::Rational(n1, n2) => n1 == n2
}
}
}
pub enum NumberPair {

192
src/prolog/compile.rs
View File

@@ -4,6 +4,9 @@ use prolog::codegen::*;
use prolog::machine::*;
use prolog::toplevel::*;
use std::collections::{HashMap, VecDeque};
use std::mem;
#[allow(dead_code)]
fn print_code(code: &Code) {
for clause in code {
@@ -38,11 +41,11 @@ pub fn parse_code(wam: &mut Machine, buffer: &str) -> Result<TopLevelPacket, Par
let index = MachineCodeIndex {
code_dir: &mut wam.code_dir,
op_dir: &mut wam.op_dir,
modules: &wam.modules
//modules: &wam.modules
};
let mut worker = TopLevelWorker::new(buffer.as_bytes(), atom_tbl, index);
worker.parse_code(clause_name!("user"))
worker.parse_code()
}
// throw errors if declaration or query found.
@@ -145,104 +148,121 @@ pub fn compile_packet(wam: &mut Machine, tl: TopLevelPacket) -> EvalSession
}
}
pub fn compile_listing(wam: &mut Machine, src_str: &str) -> EvalSession
{
fn get_module_name(module: &Option<Module>) -> ClauseName {
match module {
&Some(ref module) => module.module_decl.name.clone(),
_ => ClauseName::BuiltIn("user")
pub struct ListingCompiler<'a> {
wam: &'a mut Machine,
module: Option<Module>
}
impl<'a> ListingCompiler<'a> {
pub fn new(wam: &'a mut Machine) -> Self {
ListingCompiler { wam, module: None }
}
fn get_module_name(&self) -> ClauseName {
self.module.as_ref()
.map(|module| module.module_decl.name.clone())
.unwrap_or(ClauseName::BuiltIn("user"))
}
fn gen_code(&mut self, decls: Vec<(Predicate, VecDeque<TopLevel>)>, code_dir: &mut CodeDir)
-> Result<Code, SessionError>
{
let mut code = vec![];
for (decl, queue) in decls {
let (name, arity) = decl.0.first().and_then(|cl| {
let arity = cl.arity();
cl.name().map(|name| (name, arity))
}).ok_or(SessionError::NamelessEntry)?;
let p = code.len() + self.wam.code_size();
let mut decl_code = compile_relation(&TopLevel::Predicate(decl))?;
compile_appendix(&mut decl_code, Vec::from(queue))?;
let idx = code_dir.entry((name, arity)).or_insert(CodeIndex::default());
set_code_index!(idx, IndexPtr::Index(p), self.get_module_name());
code.extend(decl_code.into_iter());
}
Ok(code)
}
fn add_code(self, code: Code, indices: MachineCodeIndex) {
let code_dir = mem::replace(indices.code_dir, HashMap::new());
let op_dir = mem::replace(indices.op_dir, HashMap::new());
if let Some(mut module) = self.module {
module.code_dir.extend(as_module_code_dir(code_dir));
module.op_dir.extend(op_dir.into_iter());
self.wam.add_module(module, code);
} else {
self.wam.add_batched_code(code, code_dir);
self.wam.add_batched_ops(op_dir);
}
}
let mut module: Option<Module> = None;
}
let mut code_dir = CodeDir::new();
let mut op_dir = default_op_dir();
fn use_module(module: &mut Option<Module>, submodule: &Module, indices: &mut MachineCodeIndex)
{
indices.use_module(submodule);
let mut code = Vec::new();
if let &mut Some(ref mut module) = module {
module.use_module(submodule);
}
let tls = {
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);
// self.wam.use_module_in_toplevel(name);
}
try_eval_session!(worker.parse_batch(clause_name!("user")))
};
fn use_qualified_module(module: &mut Option<Module>, submodule: &Module, exports: &Vec<PredicateKey>,
indices: &mut MachineCodeIndex)
{
indices.use_qualified_module(submodule, exports);
for tl in tls {
match tl {
TopLevelPacket::Query(..) =>
return EvalSession::from(ParserError::ExpectedRel),
TopLevelPacket::Decl(TopLevel::Declaration(Declaration::Module(module_decl)), _) =>
if module.is_none() {
module = Some(Module::new(module_decl));
if let &mut Some(ref mut module) = module {
module.use_qualified_module(submodule, exports);
}
// self.wam.use_qualified_module_in_toplevel(name, exports);
}
pub fn compile_listing(wam: &mut Machine, src_str: &str) -> EvalSession {
let mut indices = machine_code_index!(&mut CodeDir::new(), &mut default_op_dir());
let mut worker = TopLevelBatchWorker::new(src_str.as_bytes(), wam.atom_tbl());
let mut compiler = ListingCompiler::new(wam);
while let Some(decl) = try_eval_session!(worker.consume(&mut indices)) {
match decl {
Declaration::Op(op_decl) =>
try_eval_session!(op_decl.submit(compiler.get_module_name(), &mut indices.op_dir)),
Declaration::UseModule(name) =>
if let Some(ref submodule) = compiler.wam.get_module(name.clone()) {
use_module(&mut compiler.module, submodule, &mut indices);
} else {
return EvalSession::from(SessionError::ModuleNotFound);
},
Declaration::UseQualifiedModule(name, exports) =>
if let Some(ref submodule) = compiler.wam.get_module(name.clone()) {
use_qualified_module(&mut compiler.module, submodule, &exports, &mut indices);
} else {
return EvalSession::from(SessionError::ModuleNotFound);
},
Declaration::Module(module_decl) =>
if compiler.module.is_none() {
worker.source_mod = module_decl.name.clone();
compiler.module = Some(Module::new(module_decl));
} else {
return EvalSession::from(ParserError::InvalidModuleDecl);
},
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, &wam.modules);
module.use_module(submodule);
code_index.use_module(submodule);
continue;
}
} else {
return EvalSession::from(SessionError::ModuleNotFound);
}
wam.use_module_in_toplevel(name);
},
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, &wam.modules);
module.use_qualified_module(submodule, &exports);
code_index.use_qualified_module(submodule, &exports);
continue;
}
} else {
return EvalSession::from(SessionError::ModuleNotFound);
}
wam.use_qualified_module_in_toplevel(name, exports);
},
TopLevelPacket::Decl(TopLevel::Declaration(Declaration::Op(..)), _) => {},
TopLevelPacket::Decl(decl, queue) => {
let p = code.len() + wam.code_size();
let mut decl_code = try_eval_session!(compile_relation(&decl));
try_eval_session!(compile_appendix(&mut decl_code, queue));
let name = try_eval_session!(if let Some(name) = decl.name() {
Ok(name)
} else {
Err(SessionError::NamelessEntry)
});
if let Some(ref mut idx) = code_dir.get_mut(&(name, decl.arity())) {
set_code_index!(idx, IndexPtr::Index(p), get_module_name(&module));
}
code.extend(decl_code.into_iter());
}
}
}
if let Some(mut module) = module {
module.code_dir.extend(as_module_code_dir(code_dir));
module.op_dir.extend(op_dir.into_iter());
wam.add_module(module, code);
} else {
wam.add_batched_code(code, code_dir);
wam.add_batched_ops(op_dir);
}
let code = try_eval_session!(compiler.gen_code(worker.results, &mut indices.code_dir));
compiler.add_code(code, indices);
EvalSession::EntrySuccess
}

16
src/prolog/machine/machine_state_impl.rs
View File

@@ -1235,14 +1235,16 @@ impl MachineState {
}
fn compare_numbers(&mut self, cmp: CompareNumberQT, n1: Number, n2: Number) {
let ordering = n1.cmp(&n2);
self.fail = match cmp {
CompareNumberQT::GreaterThan if !(n1.gt(n2)) => true,
CompareNumberQT::GreaterThanOrEqual if !(n1.gte(n2)) => true,
CompareNumberQT::LessThan if !(n1.lt(n2)) => true,
CompareNumberQT::LessThanOrEqual if !(n1.lte(n2)) => true,
CompareNumberQT::NotEqual if !(n1.ne(n2)) => true,
CompareNumberQT::Equal if !(n1.eq(n2)) => true,
_ => false
CompareNumberQT::GreaterThan if ordering == Ordering::Greater => false,
CompareNumberQT::GreaterThanOrEqual if ordering != Ordering::Less => false,
CompareNumberQT::LessThan if ordering == Ordering::Less => false,
CompareNumberQT::LessThanOrEqual if ordering != Ordering::Greater => false,
CompareNumberQT::NotEqual if ordering != Ordering::Equal => false,
CompareNumberQT::Equal if ordering == Ordering::Equal => false,
_ => true
};
self.p += 1;

15
src/prolog/machine/mod.rs
View File

@@ -20,7 +20,7 @@ use std::rc::Rc;
pub struct MachineCodeIndex<'a> {
pub code_dir: &'a mut CodeDir,
pub op_dir: &'a mut OpDir,
pub modules: &'a ModuleDir
// pub modules: &'a ModuleDir
}
impl<'a> MachineCodeIndex<'a> {
@@ -111,13 +111,14 @@ impl Machine {
cached_query: None
};
compile_listing(&mut wam, BUILTINS);
wam.use_module_in_toplevel(clause_name!("builtins"));
compile_listing(&mut wam, BUILTINS);
compile_listing(&mut wam, LISTS);
compile_listing(&mut wam, CONTROL);
compile_listing(&mut wam, QUEUES);
wam.use_module_in_toplevel(clause_name!("builtins"));
wam
}
@@ -182,8 +183,8 @@ impl Machine {
if let Some(mut module) = self.modules.remove(&name) {
let result = {
let mut indices = machine_code_index!(&mut self.code_dir, &mut self.op_dir,
&self.modules);
let mut indices = machine_code_index!(&mut self.code_dir, &mut self.op_dir);
//&self.modules);
indices.use_qualified_module(&mut module, &exports)
};
@@ -200,8 +201,8 @@ impl Machine {
if let Some(mut module) = self.modules.remove(&name) {
let result = {
let mut indices = machine_code_index!(&mut self.code_dir, &mut self.op_dir,
&self.modules);
let mut indices = machine_code_index!(&mut self.code_dir, &mut self.op_dir);
//&self.modules);
indices.use_module(&mut module)
};

4
src/prolog/macros.rs
View File

@@ -234,8 +234,8 @@ macro_rules! set_code_index {
}
macro_rules! machine_code_index {
($code_dir:expr, $op_dir:expr, $modules:expr) => (
MachineCodeIndex { code_dir: $code_dir, op_dir: $op_dir, modules: $modules }
($code_dir:expr, $op_dir:expr) => ( //, $modules:expr) => (
MachineCodeIndex { code_dir: $code_dir, op_dir: $op_dir } //, modules: $modules }
)
}

136
src/prolog/toplevel.rs
View File

@@ -212,9 +212,8 @@ fn merge_clauses(tls: &mut VecDeque<TopLevel>) -> Result<TopLevel, ParserError>
}
}
fn append_preds(preds: &mut Vec<PredicateClause>) -> TopLevel {
let preds = mem::replace(preds, vec![]);
TopLevel::Predicate(Predicate(preds))
fn append_preds(preds: &mut Vec<PredicateClause>) -> Predicate {
Predicate(mem::replace(preds, vec![]))
}
fn unfold_by_str_once(term: &mut Term, s: &str) -> Option<(Term, Term)>
@@ -295,13 +294,12 @@ pub enum TopLevelPacket {
}
struct RelationWorker {
queue: VecDeque<VecDeque<Term>>,
source_mod: ClauseName
queue: VecDeque<VecDeque<Term>>
}
impl RelationWorker {
fn new(source_mod: ClauseName) -> Self {
RelationWorker { queue: VecDeque::new(), source_mod }
fn new() -> Self {
RelationWorker { queue: VecDeque::new() }
}
fn compute_head(&self, term: &Term) -> Vec<Term>
@@ -393,7 +391,8 @@ impl RelationWorker {
self.fabricate_rule(fold_by_str(prec_seq, body_term, comma_sym))
}
fn to_query_term(&mut self, indices: &mut MachineCodeIndex, 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)) =>
@@ -562,7 +561,7 @@ impl RelationWorker {
}
}
pub struct TopLevelWorker<'a, R> where R: Read {
pub struct TopLevelWorker<'a, R: Read> {
pub parser: Parser<R>,
indices: MachineCodeIndex<'a>
}
@@ -572,72 +571,9 @@ impl<'a, R: Read> TopLevelWorker<'a, R> {
TopLevelWorker { parser: Parser::new(inner, atom_tbl), indices }
}
fn add_predicate(&mut self, tl: TopLevel) -> Vec<PredicateClause>
pub fn parse_code(&mut self) -> Result<TopLevelPacket, ParserError>
{
match tl {
TopLevel::Rule(rule) => vec![PredicateClause::Rule(rule)],
TopLevel::Fact(fact) => vec![PredicateClause::Fact(fact)],
TopLevel::Predicate(preds) => preds.0,
_ => vec![]
}
}
pub fn parse_batch(&mut self, source_mod: ClauseName) -> Result<Vec<TopLevelPacket>, SessionError>
{
let mut preds = vec![];
let mut results = vec![];
let mut mod_name = clause_name!("user");
let mut rel_worker = RelationWorker::new(source_mod.clone());
while !self.parser.eof() {
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(source_mod.clone());
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.
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) = 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();
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 => if tl.name().is_some() {
preds.extend(self.add_predicate(tl))
} else {
return Err(SessionError::NamelessEntry)
}
};
}
if !preds.is_empty() {
results.push(deque_to_packet(append_preds(&mut preds),
rel_worker.parse_queue(&mut self.indices)?));
}
Ok(results)
}
pub fn parse_code(&mut self, source_mod: ClauseName) -> Result<TopLevelPacket, ParserError>
{
let mut rel_worker = RelationWorker::new(source_mod);
let mut rel_worker = RelationWorker::new();
let terms = self.parser.read(self.indices.op_dir)?;
let mut tls = rel_worker.try_terms_to_tls(&mut self.indices, terms, true)?;
@@ -659,3 +595,55 @@ impl<'a, R: Read> TopLevelWorker<'a, R> {
}
}
}
pub struct TopLevelBatchWorker<R: Read> {
parser: Parser<R>,
rel_worker: RelationWorker,
pub source_mod: ClauseName,
pub results: Vec<(Predicate, VecDeque<TopLevel>)>
}
impl<R: Read> TopLevelBatchWorker<R> {
pub fn new(inner: R, atom_tbl: TabledData<Atom>) -> Self {
TopLevelBatchWorker { parser: Parser::new(inner, atom_tbl),
rel_worker: RelationWorker::new(),
source_mod: clause_name!("user"),
results: vec![] }
}
pub
fn consume(&mut self, indices: &mut MachineCodeIndex) -> Result<Option<Declaration>, SessionError>
{
let mut preds = vec![];
while !self.parser.eof() {
self.parser.reset(); // empty the parser stack of token descriptions.
let mut new_rel_worker = RelationWorker::new();
let term = self.parser.read_term(&indices.op_dir)?;
let tl = new_rel_worker.try_term_to_tl(indices, term, true)?;
if !is_consistent(&tl, &preds) { // if is_consistent returns false, preds is non-empty.
let result_queue = self.rel_worker.parse_queue(indices)?;
self.results.push((append_preds(&mut preds), result_queue));
}
self.rel_worker.absorb(new_rel_worker);
match tl {
TopLevel::Fact(fact) => preds.push(PredicateClause::Fact(fact)),
TopLevel::Rule(rule) => preds.push(PredicateClause::Rule(rule)),
TopLevel::Predicate(pred) => preds.extend(pred.0),
TopLevel::Declaration(decl) => return Ok(Some(decl)),
TopLevel::Query(_) => return Err(SessionError::NamelessEntry)
}
}
if !preds.is_empty() {
let result_queue = self.rel_worker.parse_queue(indices)?;
self.results.push((append_preds(&mut preds), result_queue));
}
Ok(None)
}
}