[[package]]
name = "prolog_parser"
-version = "0.7.10"
+version = "0.7.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"num 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"downcast 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
"num 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"ordered-float 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "prolog_parser 0.7.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "prolog_parser 0.7.11 (registry+https://github.com/rust-lang/crates.io-index)",
"termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
"checksum num-traits 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)" = "cacfcab5eb48250ee7d0c7896b51a2c5eec99c1feea5f32025635f5ae4b00070"
"checksum num-traits 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "630de1ef5cc79d0cdd78b7e33b81f083cbfe90de0f4b2b2f07f905867c70e9fe"
"checksum ordered-float 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "58d25b6c0e47b20d05226d288ff434940296e7e2f8b877975da32f862152241f"
-"checksum prolog_parser 0.7.10 (registry+https://github.com/rust-lang/crates.io-index)" = "277adc8aef82e87336a642a9bbd480cac9550e5ec63c99465eed7cbc7c165808"
+"checksum prolog_parser 0.7.11 (registry+https://github.com/rust-lang/crates.io-index)" = "608b6d0e85a6ea8d4fda3679fc314a8b08efdb07f896438342a9d727b04b72d7"
"checksum redox_syscall 0.1.32 (registry+https://github.com/rust-lang/crates.io-index)" = "ab105df655884ede59d45b7070c8a65002d921461ee813a024558ca16030eea0"
"checksum redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7e891cfe48e9100a70a3b6eb652fef28920c117d366339687bd5576160db0f76"
"checksum termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "689a3bdfaab439fd92bc87df5c4c78417d3cbe537487274e9b0b2dce76e92096"
downcast = "0.9.1"
num = "0.2"
ordered-float = "0.5.0"
-prolog_parser = "0.7.10"
+prolog_parser = "0.7.11"
[dependencies.termion]
version = "1.4.0"
\ No newline at end of file
and so do conjunctive queries:
```
prolog> f(X) :- g(X).
-prolog> g(x). g(y). g(z).
+prolog> :{
+g(x). g(y). g(z).
+}:
prolog> h(call(f, X)).
prolog> ?- h(X), X.
true .
mod prolog;
use prolog::compile::*;
-use prolog::io::*;
use prolog::machine::*;
+use prolog::read::*;
+use prolog::write::*;
+
+use std::io::{Write, stdout};
#[cfg(test)]
mod tests;
let result = compile_packet(wam, packet);
print(wam, result);
},
- Err(s) => println!("{:?}", s)
+ Err(e) => print(wam, EvalSession::from(e))
}
}
loop {
print!("prolog> ");
-
- match read() {
- Input::Line(line) => parse_and_compile_line(&mut wam, line.as_str()),
- Input::Batch(batch) =>
- match compile_user_module(&mut wam, batch.as_str()) {
- EvalSession::Error(e) => println!("{}", e),
- _ => {}
+ stdout().flush().unwrap();
+
+ match read_toplevel(&mut wam) {
+ Ok(Input::Term(term)) =>
+ match compile_term(&mut wam, term) {
+ Ok(packet) => {
+ let result = compile_packet(&mut wam, packet);
+ print(&mut wam, result);
+ },
+ Err(e) => print(&mut wam, EvalSession::from(e))
},
- Input::Quit => break,
- Input::Clear => {
+ Ok(Input::Line(line)) => parse_and_compile_line(&mut wam, line.as_str()),
+ Ok(Input::Batch(batch)) => {
+ let result = compile_user_module(&mut wam, batch.as_bytes());
+ print(&mut wam, result);
+ },
+ Ok(Input::Quit) => break,
+ Ok(Input::Clear) => {
wam.clear();
continue;
- }
+ },
+ Err(e) => print(&mut wam, EvalSession::from(e))
};
wam.reset();
use prolog::toplevel::*;
use std::collections::{HashMap, HashSet, VecDeque};
+use std::io::Read;
use std::mem;
#[allow(dead_code)]
worker.parse_code()
}
+pub fn compile_term(wam: &mut Machine, term: Term) -> Result<TopLevelPacket, ParserError> {
+ let indices = machine_code_indices!(&mut wam.code_dir, &mut wam.op_dir, &mut HashMap::new());
+ parse_term(term, indices)
+}
+
// throw errors if declaration or query found.
fn compile_relation(tl: &TopLevel, non_counted_bt: bool, flags: MachineFlags) -> Result<Code, ParserError>
{
try_eval_session!(compile_appendix(&mut code, queue, false, wam.machine_flags()));
if !code.is_empty() {
- wam.add_user_code(name, tl.arity(), code, tl.as_predicate().ok().unwrap())
+ wam.add_user_code(name, tl.arity(), code)
} else {
EvalSession::from(SessionError::ImpermissibleEntry(String::from("no code generated.")))
}
.unwrap_or(ClauseName::BuiltIn("user"))
}
- fn gen_code(&mut self, decls: Vec<(Predicate, VecDeque<TopLevel>)>, code_dir: &mut CodeDir)
- -> Result<Code, SessionError>
+ fn generate_code(&mut self, decls: Vec<(Predicate, VecDeque<TopLevel>)>, code_dir: &mut CodeDir)
+ -> Result<Code, SessionError>
{
let mut code = vec![];
}
pub
-fn compile_listing(wam: &mut Machine, src_str: &str, mut indices: MachineCodeIndices) -> EvalSession
+fn compile_listing<R: Read>(wam: &mut Machine, src: R, mut indices: MachineCodeIndices) -> EvalSession
{
- let mut worker = TopLevelBatchWorker::new(src_str.as_bytes(), wam.atom_tbl(), wam.machine_flags());
+ let mut worker = TopLevelBatchWorker::new(src, wam.atom_tbl(), wam.machine_flags());
let mut compiler = ListingCompiler::new(wam);
while let Some(decl) = try_eval_session!(worker.consume(&mut indices)) {
}
}
- let code = try_eval_session!(compiler.gen_code(worker.results, &mut indices.code_dir));
+ let code = try_eval_session!(compiler.generate_code(worker.results, &mut indices.code_dir));
compiler.add_code(code, indices);
EvalSession::EntrySuccess
}
-pub fn compile_user_module(wam: &mut Machine, src_str: &str) -> EvalSession {
+pub fn compile_user_module<R: Read>(wam: &mut Machine, src: R) -> EvalSession {
let mut indices = machine_code_indices!(&mut CodeDir::new(), &mut default_op_dir(),
&mut HashMap::new());
return EvalSession::from(SessionError::ModuleNotFound);
}
- compile_listing(wam, src_str, indices)
+ compile_listing(wam, src, indices)
}
&InlinedClauseType::IsAtom(..) => "atom",
&InlinedClauseType::IsAtomic(..) => "atomic",
&InlinedClauseType::IsCompound(..) => "compound",
- &InlinedClauseType::IsInteger (..) => "integer",
+ &InlinedClauseType::IsInteger (..) => "integer",
&InlinedClauseType::IsRational(..) => "rational",
&InlinedClauseType::IsString(..) => "string",
&InlinedClauseType::IsFloat (..) => "float",
pub type CodeDir = HashMap<PredicateKey, CodeIndex>;
-pub type TermDir = HashMap<PredicateKey, Predicate>;
+
//pub type TermDir = HashMap<PredicateKey, Predicate>;
pub type ModuleDir = HashMap<ClauseName, Module>;
pub struct CodeIndex(pub Rc<RefCell<(IndexPtr, ClauseName)>>);
impl CodeIndex {
+ #[inline]
pub fn is_undefined(&self) -> bool {
let index_ptr = &self.0.borrow().0;
&TopLevel::Rule(Rule { ref head, .. }) => head.1.len()
}
}
-
- pub fn as_predicate(self) -> Result<Predicate, TopLevel> {
- match self {
- TopLevel::Fact(term) => Ok(Predicate(vec![PredicateClause::Fact(term)])),
- TopLevel::Rule(rule) => Ok(Predicate(vec![PredicateClause::Rule(rule)])),
- TopLevel::Predicate(pred) => Ok(pred),
- _ => Err(self)
- }
- }
}
#[derive(Clone, Copy)]
OpIsInfixAndPostFix,
ParserError(ParserError),
QueryFailure,
- QueryFailureWithException(String)
+ QueryFailureWithException(String)
}
pub enum EvalSession {
}
pub(super) fn syntax_error(h: usize, err: ParserError) -> Self {
- let err = match err {
- ParserError::Arithmetic(_) =>
- vec![heap_atom!("arithmetic_error")],
- ParserError::BackQuotedString =>
- vec![heap_atom!("back_quoted_string")],
- ParserError::UnexpectedChar(c) =>
- functor!("unexpected_char", 1, [heap_char!(c)]),
- ParserError::UnexpectedEOF =>
- vec![heap_atom!("unexpected_end_of_file")],
- ParserError::ExpectedRel =>
- vec![heap_atom!("expected_relation")],
- ParserError::InadmissibleFact =>
- vec![heap_atom!("inadmissible_fact")],
- ParserError::InadmissibleQueryTerm =>
- vec![heap_atom!("inadmissible_query_term")],
- ParserError::IncompleteReduction =>
- vec![heap_atom!("incomplete_reduction")],
- ParserError::InconsistentEntry =>
- vec![heap_atom!("inconsistent_entry")],
- ParserError::InvalidModuleDecl =>
- vec![heap_atom!("invalid_module_declaration")],
- ParserError::InvalidModuleExport =>
- vec![heap_atom!("invalid_module_export")],
- ParserError::InvalidModuleResolution =>
- vec![heap_atom!("invalid_module_resolution")],
- ParserError::InvalidRuleHead =>
- vec![heap_atom!("invalid_head_of_rule")],
- ParserError::InvalidUseModuleDecl =>
- vec![heap_atom!("invalid_use_module_declaration")],
- ParserError::IO(_) =>
- vec![heap_atom!("input_output_error")],
- ParserError::MissingQuote =>
- vec![heap_atom!("missing_quote")],
- ParserError::NonPrologChar =>
- vec![heap_atom!("non_prolog_character")],
- ParserError::ParseBigInt =>
- vec![heap_atom!("cannot_parse_big_int")],
- ParserError::ParseFloat =>
- vec![heap_atom!("cannot_parse_float")],
- ParserError::Utf8Conversion(_) =>
- vec![heap_atom!("utf8_conversion_error")]
- };
+ let err = vec![heap_atom!(err.as_str())];
let mut stub = if err.len() == 1 {
functor!("syntax_error", 1)
use prolog::machine::machine_errors::*;
use prolog::num::{BigInt, BigUint, Zero, One};
use prolog::or_stack::*;
-use prolog::read::*;
use downcast::Any;
use std::cell::RefCell;
use std::cmp::Ordering;
+use std::io::stdin;
use std::mem::swap;
use std::ops::{Index, IndexMut};
use std::rc::Rc;
pub(super) ball: Ball,
pub(super) interms: Vec<Number>, // intermediate numbers.
pub(super) last_call: bool,
- pub(super) flags: MachineFlags
+ pub(crate) flags: MachineFlags
}
fn call_at_index(machine_st: &mut MachineState, module_name: ClauseName, arity: usize, idx: usize)
machine_st.fail = !machine_st.is_cyclic_term(addr);
return_from_clause!(machine_st.last_call, machine_st)
},
- &BuiltInClauseType::Read => {
- let mut reader = Reader::new(machine_st);
-
- match reader.read_stdin(&indices.op_dir) {
+ &BuiltInClauseType::Read => {
+ match machine_st.read(stdin(), &indices.op_dir) {
Ok(offset) => {
- let addr = reader.machine_st[temp_v!(1)].clone();
- reader.machine_st.unify(addr, Addr::HeapCell(offset));
+ let addr = machine_st[temp_v!(1)].clone();
+ machine_st.unify(addr, Addr::HeapCell(offset));
},
Err(e) => {
- let h = reader.machine_st.heap.h;
+ let h = machine_st.heap.h;
let stub = MachineError::functor_stub(clause_name!("read"), 1);
let err = MachineError::syntax_error(h, e);
- let err = reader.machine_st.error_form(err, stub);
+ let err = machine_st.error_form(err, stub);
return Err(err);
}
};
- return_from_clause!(reader.machine_st.last_call, reader.machine_st)
+ return_from_clause!(machine_st.last_call, machine_st)
},
&BuiltInClauseType::Writeq => {
let output = machine_st.print_term(machine_st[temp_v!(1)].clone(),
code: Code,
pub(super) code_dir: CodeDir,
pub(super) op_dir: OpDir,
- term_dir: TermDir,
+ // term_dir: TermDir,
pub(super) modules: ModuleDir,
cached_query: Option<Code>
}
code: Code::new(),
code_dir: CodeDir::new(),
op_dir: default_op_dir(),
- term_dir: TermDir::new(),
+ // term_dir: TermDir::new(),
modules: HashMap::new(),
cached_query: None
};
let indices = machine_code_indices!(&mut CodeDir::new(), &mut default_op_dir(),
&mut HashMap::new());
- compile_listing(&mut wam, BUILTINS, indices);
+ compile_listing(&mut wam, BUILTINS.as_bytes(), indices);
- compile_user_module(&mut wam, LISTS);
- compile_user_module(&mut wam, CONTROL);
- compile_user_module(&mut wam, QUEUES);
+ compile_user_module(&mut wam, LISTS.as_bytes());
+ compile_user_module(&mut wam, CONTROL.as_bytes());
+ compile_user_module(&mut wam, QUEUES.as_bytes());
wam.use_module_in_toplevel(clause_name!("builtins"));
self.code.extend(code.into_iter());
}
- pub fn add_user_code(&mut self, name: ClauseName, arity: usize, code: Code, pred: Predicate)
- -> EvalSession
+ pub fn add_user_code(&mut self, name: ClauseName, arity: usize, code: Code) -> EvalSession
{
match self.code_dir.get(&(name.clone(), arity)) {
Some(&CodeIndex (ref idx)) if idx.borrow().1 != clause_name!("user") =>
let offset = self.code.len();
self.code.extend(code.into_iter());
- self.term_dir.insert((name.clone(), arity), pred);
+ //self.term_dir.insert((name.clone(), arity), pred);
let idx = self.code_dir.entry((name, arity))
.or_insert(CodeIndex::from((offset, clause_name!("user"))));
)
}
-macro_rules! heap_char {
- ($c:expr) => (
- HeapCellValue::Addr(Addr::Con(Constant::Char($c)))
- )
-}
-
macro_rules! heap_atom {
($name:expr) => (
HeapCellValue::Addr(Addr::Con(atom!($name)))
mod fixtures;
mod heap_iter;
mod indexing;
-pub mod io;
+pub mod write;
mod iterators;
mod or_stack;
pub mod heap_print;
mod targets;
-mod read;
+pub mod read;
use prolog::instructions::*;
use prolog::iterators::*;
-use prolog::machine::machine_state::*;
+use prolog::machine::*;
+use prolog::machine::machine_state::MachineState;
use std::collections::VecDeque;
-use std::io::stdin;
-
-pub struct Reader<'a> {
- pub machine_st: &'a mut MachineState,
-}
+use std::io::{Read, stdin};
type SubtermDeque = VecDeque<(usize, usize)>;
}
}
-impl<'a> Reader<'a> {
- pub fn new(machine_st: &'a mut MachineState) -> Self {
- Reader { machine_st }
- }
+pub enum Input {
+ Quit,
+ Clear,
+ Line(String),
+ Batch(String),
+ Term(Term)
+}
- fn read_term(&self, buffer: &String, op_dir: &'a OpDir) -> Result<Term, ParserError> {
- let mut parser = Parser::new(buffer.as_bytes(), self.machine_st.atom_tbl.clone(),
- self.machine_st.machine_flags());
+fn read_lines(buffer: &mut String, end_delim: &str) -> String {
+ let mut result = String::new();
+ let stdin = stdin();
- parser.read_term(op_dir)
- }
-
- fn read_term_loop(&mut self, buffer: &mut String, op_dir: &'a OpDir) -> Result<Term, ParserError> {
- let stdin = stdin();
-
- loop {
- match self.read_term(&buffer, op_dir) {
- Err(ParserError::UnexpectedEOF) => {},
- result => return result
- };
-
- let mut append_buf = String::new();
- stdin.read_line(&mut append_buf).unwrap();
- *buffer += append_buf.as_str();
- }
- }
-/*
- pub fn repl_read(&mut self, op_dir: &'a OpDir) -> Result<Vec<Term>, ParserError> {
- let mut buffer = String::new();
+ buffer.clear();
+ stdin.read_line(buffer).unwrap();
- stdin().read_line(&mut buffer);
+ while &*buffer.trim() != end_delim {
+ result += buffer.as_str();
+ buffer.clear();
+ stdin.read_line(buffer).unwrap();
+ }
- if buffer.as_str() == "[user]" {
- let locked = stdin().lock();
- let mut parser = Parser::new(locked, self.machine_st.atom_tbl.clone(),
- self.machine_st.flags());
+ result
+}
- parser.read(op_dir)
- } else {
- Ok(vec![self.read_term_loop(buffer, op_dir)?])
+pub fn read_toplevel(wam: &Machine) -> Result<Input, ParserError> {
+ let mut buffer = String::new();
+
+ let stdin = stdin();
+ stdin.read_line(&mut buffer).unwrap();
+
+ match &*buffer.trim() {
+ ":{" => Ok(Input::Line(read_lines(&mut buffer, "}:"))),
+ ":{{" => Ok(Input::Batch(read_lines(&mut buffer, "}}:"))),
+ "quit" => Ok(Input::Quit),
+ "clear" => Ok(Input::Clear),
+ _ => {
+ let mut parser = Parser::new(stdin.lock(), wam.atom_tbl(), wam.machine_flags());
+
+ parser.add_to_top(buffer.as_str());
+ Ok(Input::Term(parser.read_term(&wam.op_dir)?))
}
}
-*/
- pub fn read_stdin(&mut self, op_dir: &'a OpDir) -> Result<usize, ParserError>
+}
+
+impl MachineState {
+ pub fn read<R: Read>(&mut self, inner: R, op_dir: &OpDir) -> Result<usize, ParserError>
{
- let term = self.read_term_loop(&mut String::new(), op_dir)?;
- Ok(self.write_term_to_heap(term))
- }
+ let mut parser = Parser::new(inner, self.atom_tbl.clone(), self.flags);
+ let term = parser.read_term(op_dir)?;
- fn push_stub_addr(&mut self) {
- let h = self.machine_st.heap.h;
- self.machine_st.heap.push(HeapCellValue::Addr(Addr::HeapCell(h)));
+ Ok(write_term_to_heap(term, self))
}
+}
- fn modify_head_of_queue(&mut self, queue: &mut SubtermDeque, term: TermRef, h: usize) {
- if let Some((arity, site_h)) = queue.pop_front() {
- self.machine_st.heap[site_h] = HeapCellValue::Addr(term.as_addr(h));
+fn push_stub_addr(machine_st: &mut MachineState) {
+ let h = machine_st.heap.h;
+ machine_st.heap.push(HeapCellValue::Addr(Addr::HeapCell(h)));
+}
+
+fn modify_head_of_queue(machine_st: &mut MachineState, queue: &mut SubtermDeque, term: TermRef, h: usize)
+{
+ if let Some((arity, site_h)) = queue.pop_front() {
+ machine_st.heap[site_h] = HeapCellValue::Addr(term.as_addr(h));
- if arity > 1 {
- queue.push_front((arity - 1, site_h + 1));
- }
+ if arity > 1 {
+ queue.push_front((arity - 1, site_h + 1));
}
}
+}
- fn write_term_to_heap(&mut self, term: Term) -> usize {
- let h = self.machine_st.heap.h;
+fn write_term_to_heap(term: Term, machine_st: &mut MachineState) -> usize {
+ let h = machine_st.heap.h;
- let mut queue = SubtermDeque::new();
- let mut var_dict = HeapVarDict::new();
+ let mut queue = SubtermDeque::new();
+ let mut var_dict = HeapVarDict::new();
- for term in breadth_first_iter(&term, true) {
- let h = self.machine_st.heap.h;
+ for term in breadth_first_iter(&term, true) {
+ let h = machine_st.heap.h;
- match &term {
- &TermRef::Cons(lvl, ..) => {
- queue.push_back((2, h+1));
- self.machine_st.heap.push(HeapCellValue::Addr(Addr::Lis(h+1)));
+ match &term {
+ &TermRef::Cons(lvl, ..) => {
+ queue.push_back((2, h+1));
+ machine_st.heap.push(HeapCellValue::Addr(Addr::Lis(h+1)));
- self.push_stub_addr();
- self.push_stub_addr();
+ push_stub_addr(machine_st);
+ push_stub_addr(machine_st);
- if let Level::Root = lvl {
- continue;
- }
- },
- &TermRef::Clause(lvl, _, ref ct, subterms) => {
- queue.push_back((subterms.len(), h+1));
- let named = HeapCellValue::NamedStr(subterms.len(), ct.name(),
- ct.fixity());
+ if let Level::Root = lvl {
+ continue;
+ }
+ },
+ &TermRef::Clause(lvl, _, ref ct, subterms) => {
+ queue.push_back((subterms.len(), h+1));
+ let named = HeapCellValue::NamedStr(subterms.len(), ct.name(), ct.fixity());
- self.machine_st.heap.push(named);
+ machine_st.heap.push(named);
- for _ in 0 .. subterms.len() {
- self.push_stub_addr();
- }
+ for _ in 0 .. subterms.len() {
+ push_stub_addr(machine_st);
+ }
- if let Level::Root = lvl {
- continue;
- }
- },
- &TermRef::AnonVar(Level::Root)
- | &TermRef::Var(Level::Root, ..)
- | &TermRef::Constant(Level::Root, ..) =>
- self.machine_st.heap.push(HeapCellValue::Addr(term.as_addr(h))),
- &TermRef::AnonVar(_) =>
- continue,
- &TermRef::Var(_, _, ref var) => {
- if let Some((arity, site_h)) = queue.pop_front() {
- if let Some(addr) = var_dict.get(var).cloned() {
- self.machine_st.heap[site_h] = HeapCellValue::Addr(addr);
- } else {
- var_dict.insert(var.clone(), Addr::HeapCell(site_h));
- }
-
- if arity > 1 {
- queue.push_front((arity - 1, site_h + 1));
- }
+ if let Level::Root = lvl {
+ continue;
+ }
+ },
+ &TermRef::AnonVar(Level::Root)
+ | &TermRef::Var(Level::Root, ..)
+ | &TermRef::Constant(Level::Root, ..) =>
+ machine_st.heap.push(HeapCellValue::Addr(term.as_addr(h))),
+ &TermRef::AnonVar(_) =>
+ continue,
+ &TermRef::Var(_, _, ref var) => {
+ if let Some((arity, site_h)) = queue.pop_front() {
+ if let Some(addr) = var_dict.get(var).cloned() {
+ machine_st.heap[site_h] = HeapCellValue::Addr(addr);
+ } else {
+ var_dict.insert(var.clone(), Addr::HeapCell(site_h));
}
- continue;
- },
- _ => {}
- };
+ if arity > 1 {
+ queue.push_front((arity - 1, site_h + 1));
+ }
+ }
- self.modify_head_of_queue(&mut queue, term, h);
- }
+ continue;
+ },
+ _ => {}
+ };
- h
+ modify_head_of_queue(machine_st, &mut queue, term, h);
}
+
+ h
}
}
}
+pub fn parse_term(term: Term, mut indices: MachineCodeIndices) -> Result<TopLevelPacket, ParserError>
+{
+ let mut rel_worker = RelationWorker::new();
+
+ let tl = rel_worker.try_term_to_tl(&mut indices, term, true)?;
+ let results = rel_worker.parse_queue(&mut indices)?;
+
+ Ok(deque_to_packet(tl, results))
+}
+
pub struct TopLevelBatchWorker<R: Read> {
parser: Parser<R>,
rel_worker: RelationWorker,
{
let mut preds = vec![];
- while !self.parser.eof() {
+ while !self.parser.eof()? {
self.parser.reset(); // empty the parser stack of token descriptions.
let mut new_rel_worker = RelationWorker::new();
&ControlInstruction::CallClause(ref ct, arity, pvs, true, false) =>
write!(f, "execute {}/{}, {}", ct, arity, pvs),
&ControlInstruction::CallClause(ref ct, arity, pvs, false, false) =>
- write!(f, "call {}/{}, {}", ct, arity, pvs),
+ write!(f, "call {}/{}, {}", ct, arity, pvs),
&ControlInstruction::Deallocate =>
write!(f, "deallocate"),
&ControlInstruction::JmpBy(arity, offset, pvs, false) =>
impl fmt::Display for ChoiceInstruction {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- match self {
+ match self {
&ChoiceInstruction::TryMeElse(offset) =>
write!(f, "try_me_else {}", offset),
&ChoiceInstruction::DefaultRetryMeElse(offset) =>
&SessionError::OpIsInfixAndPostFix =>
write!(f, "cannot define an op to be both postfix and infix."),
&SessionError::NamelessEntry => write!(f, "the predicate head is not an atom or clause."),
- &SessionError::ParserError(ref e) => write!(f, "{:?}", e)
+ &SessionError::ParserError(ref e) => write!(f, "syntax_error({})", e.as_str()),
}
}
}
}
}
-pub enum Input {
- Quit,
- Clear,
- Line(String),
- Batch(String)
-}
-
-fn read_lines(buffer: &mut String, end_delim: &str) -> String {
- let mut result = String::new();
- let stdin = stdin();
-
- buffer.clear();
- stdin.read_line(buffer).unwrap();
-
- while &*buffer.trim() != end_delim {
- result += buffer.as_str();
- buffer.clear();
- stdin.read_line(buffer).unwrap();
- }
-
- result
-}
-
-pub fn read() -> Input {
- let _ = stdout().flush();
- let mut buffer = String::new();
-
- let stdin = stdin();
- stdin.read_line(&mut buffer).unwrap();
-
- match &*buffer.trim() {
- ":{" => Input::Line(read_lines(&mut buffer, "}:")),
- ":{{" => Input::Batch(read_lines(&mut buffer, "}}:")),
- "quit" => Input::Quit,
- "clear" => Input::Clear,
- _ => Input::Line(buffer)
- }
-}
-
pub fn print(wam: &mut Machine, result: EvalSession) {
match result {
EvalSession::InitialQuerySuccess(alloc_locs, mut heap_locs) => {
- print!("true");
-
- if !wam.or_stack_is_empty() {
- print!(" ");
- }
-
- println!(".");
-
if heap_locs.is_empty() {
+ println!("true.");
return;
}
+
+ if !wam.or_stack_is_empty() {
+ println!("true .");
+ }
loop {
let mut result = EvalSession::from(SessionError::QueryFailure);
true,
_ => false
},
- Err(e) => panic!("parse error: {:?}", e)
+ Err(e) => panic!("syntax_error({})", e.as_str())
}
}
EvalSession::EntrySuccess => true,
_ => false
},
- Err(e) => panic!("parse error: {:?}", e)
+ Err(e) => panic!("syntax_error({})", e.as_str())
}
}
EvalSession::EntrySuccess => true,
_ => false
},
- Err(e) => panic!("parse error: {:?}", e)
+ Err(e) => panic!("syntax_error({})", e.as_str())
}
}
local_member(X, Xs) :- member(X, Xs).
reverse(Xs, Ys) :- lists:reverse(Xs, Ys).
-");
+".as_bytes());
assert_prolog_success!(&mut wam, "?- my_lists:local_member(1, [1,2,3]).");
assert_prolog_success!(&mut wam, "?- my_lists:reverse([a,b,c], [c,b,a]).");
compile_user_module(&mut wam, "
:- use_module(library(my_lists), [local_member/2]).
:- module(my_lists_2, [local_member/2]).
-");
+".as_bytes());
assert_prolog_success!(&mut wam, "?- my_lists_2:local_member(1, [1,2,3]).");
assert_prolog_success!(&mut wam, "?- catch(local_member(X, Xs), error(E, _), true).",
[["X = _1", "E = existence_error(procedure, local_member/2)", "Xs = _2"]]);
-
-
}
#[test]
projects / scryer-prolog.git / commitdiff