323 lines
11 KiB
Rust
323 lines
11 KiB
Rust
use prolog::ast::*;
|
|
use prolog::debray_allocator::*;
|
|
use prolog::codegen::*;
|
|
use prolog::machine::*;
|
|
use prolog::toplevel::*;
|
|
|
|
#[allow(dead_code)]
|
|
fn print_code(code: &Code) {
|
|
for clause in code {
|
|
match clause {
|
|
&Line::Arithmetic(ref arith) =>
|
|
println!("{}", arith),
|
|
&Line::Fact(ref fact) =>
|
|
for fact_instr in fact {
|
|
println!("{}", fact_instr);
|
|
},
|
|
&Line::Cut(ref cut) =>
|
|
println!("{}", cut),
|
|
&Line::Choice(ref choice) =>
|
|
println!("{}", choice),
|
|
&Line::Control(ref control) =>
|
|
println!("{}", control),
|
|
&Line::IndexedChoice(ref choice) =>
|
|
println!("{}", choice),
|
|
&Line::Indexing(ref indexing) =>
|
|
println!("{}", indexing),
|
|
&Line::Query(ref query) =>
|
|
for query_instr in query {
|
|
println!("{}", query_instr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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 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.
|
|
fn compile_relation(tl: &TopLevel) -> Result<Code, ParserError>
|
|
{
|
|
let mut cg = CodeGenerator::<DebrayAllocator>::new();
|
|
|
|
match tl {
|
|
&TopLevel::Declaration(_) | &TopLevel::Query(_) =>
|
|
Err(ParserError::ExpectedRel),
|
|
&TopLevel::Predicate(ref clauses) =>
|
|
cg.compile_predicate(&clauses.0),
|
|
&TopLevel::Fact(ref fact) =>
|
|
Ok(cg.compile_fact(fact)),
|
|
&TopLevel::Rule(ref rule) =>
|
|
cg.compile_rule(rule)
|
|
}
|
|
}
|
|
|
|
// set first jmp_by_call or jmp_by_index instruction to code.len() -
|
|
// idx, where idx is the place it occurs. It only does this to the
|
|
// *first* uninitialized jmp index it encounters, then returns.
|
|
fn set_first_index(code: &mut Code)
|
|
{
|
|
let code_len = code.len();
|
|
|
|
for (idx, line) in code.iter_mut().enumerate() {
|
|
match line {
|
|
&mut Line::Control(ControlInstruction::JmpBy(_, ref mut offset, ..)) if *offset == 0 => {
|
|
*offset = code_len - idx;
|
|
break;
|
|
},
|
|
_ => {}
|
|
};
|
|
}
|
|
}
|
|
|
|
fn compile_appendix(code: &mut Code, queue: Vec<TopLevel>) -> Result<(), ParserError>
|
|
{
|
|
for tl in queue.iter() {
|
|
set_first_index(code);
|
|
code.append(&mut compile_relation(tl)?);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn compile_query(terms: Vec<QueryTerm>, queue: Vec<TopLevel>, code_size: usize,
|
|
code_dir: &mut CodeDir)
|
|
-> 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()))
|
|
}
|
|
|
|
fn compile_decl(wam: &mut Machine, tl: TopLevel, queue: Vec<TopLevel>) -> EvalSession
|
|
{
|
|
match tl {
|
|
TopLevel::Declaration(Declaration::Op(op_decl)) => {
|
|
try_eval_session!(op_decl.submit(clause_name!("user"), &mut wam.op_dir));
|
|
EvalSession::EntrySuccess
|
|
},
|
|
TopLevel::Declaration(Declaration::UseModule(name)) =>
|
|
wam.use_module_in_toplevel(name),
|
|
TopLevel::Declaration(Declaration::UseQualifiedModule(name, exports)) =>
|
|
wam.use_qualified_module_in_toplevel(name, exports),
|
|
TopLevel::Declaration(_) =>
|
|
EvalSession::from(ParserError::InvalidModuleDecl),
|
|
_ => {
|
|
let name = try_eval_session!(if let Some(name) = tl.name() {
|
|
Ok(name)
|
|
} else {
|
|
Err(SessionError::NamelessEntry)
|
|
});
|
|
|
|
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 {
|
|
EvalSession::from(SessionError::ImpermissibleEntry(String::from("no code generated.")))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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) {
|
|
Ok((mut code, vars)) => wam.submit_query(code, vars),
|
|
Err(e) => EvalSession::from(e)
|
|
},
|
|
TopLevelPacket::Decl(tl, queue) =>
|
|
compile_decl(wam, tl, queue)
|
|
}
|
|
}
|
|
|
|
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")
|
|
}
|
|
}
|
|
|
|
let mut module: Option<Module> = None;
|
|
|
|
let mut code_dir = CodeDir::new();
|
|
let mut op_dir = default_op_dir();
|
|
|
|
let mut code = Vec::new();
|
|
|
|
let tls = {
|
|
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 {
|
|
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));
|
|
} 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);
|
|
|
|
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);
|
|
|
|
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)
|
|
});
|
|
|
|
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);
|
|
}
|
|
|
|
decl_info.label_clauses(p, &mut code_dir, &mut decl_code);
|
|
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);
|
|
}
|
|
|
|
EvalSession::EntrySuccess
|
|
}
|