("$unwind_stack", 0) => Some(SystemClauseType::UnwindStack),
("$unify_with_occurs_check", 2) => Some(SystemClauseType::UnifyWithOccursCheck),
("$variant", 2) => Some(SystemClauseType::Variant),
- ("$write_term", 4) => Some(SystemClauseType::WriteTerm),
+ ("$write_term", 5) => Some(SystemClauseType::WriteTerm),
_ => None
}
}
type ReverseHeapVarDict = HashMap<Addr, Rc<Var>>;
pub struct HCPrinter<'a, Outputter> {
- outputter: Outputter,
- machine_st: &'a MachineState,
+ outputter: Outputter,
+ machine_st: &'a MachineState,
op_dir: &'a OpDir,
- state_stack: Vec<TokenOrRedirect>,
+ state_stack: Vec<TokenOrRedirect>,
toplevel_spec: Option<DirectedOp>,
- heap_locs: ReverseHeapVarDict,
+ heap_locs: ReverseHeapVarDict,
printed_vars: HashSet<Addr>,
last_item_idx: usize,
cyclic_terms: HashMap<Addr, usize>,
+ pub(crate) var_names: HashMap<Addr, String>,
pub(crate) numbervars_offset: BigInt,
pub(crate) numbervars: bool,
pub(crate) quoted: bool,
}
}
-fn reverse_heap_locs<'a>(machine_st: &'a MachineState, heap_locs: &'a HeapVarDict)
- -> ReverseHeapVarDict
+fn reverse_heap_locs<'a>(machine_st: &'a MachineState) -> ReverseHeapVarDict
{
- heap_locs.iter().map(|(var, var_addr)| {
+ machine_st.heap_locs.iter().map(|(var, var_addr)| {
(machine_st.store(machine_st.deref(var_addr.clone())), var.clone())
}).collect()
}
numbervars_offset: BigInt::zero(),
quoted: false,
ignore_ops: false,
- cyclic_terms: HashMap::new() }
+ cyclic_terms: HashMap::new(),
+ var_names: HashMap::new() }
}
- pub fn from_heap_locs(machine_st: &'a MachineState, op_dir: &'a OpDir, output: Outputter,
- heap_locs: &'a HeapVarDict)
+ pub fn from_heap_locs(machine_st: &'a MachineState, op_dir: &'a OpDir, output: Outputter)
-> Self
{
let mut printer = Self::new(machine_st, op_dir, output);
printer.toplevel_spec = Some(DirectedOp::Right(clause_name!("="), SharedOpDesc::new(700, XFX)));
- printer.heap_locs = reverse_heap_locs(machine_st, heap_locs);
+ printer.heap_locs = reverse_heap_locs(machine_st);
printer
}
self.last_item_idx = self.outputter.len();
self.outputter.append(s);
}
+
+ fn offset_as_string(&self, iter: &mut HCPreOrderIterator, addr: Addr) -> Option<String>
+ {
+ if let Some(var) = self.var_names.get(&addr) {
+ if addr.as_var().is_some() {
+ return Some(format!("{}", var));
+ } else {
+ iter.stack().push(addr);
+ return None;
+ }
+ }
- fn offset_as_string(&self, addr: Addr) -> Option<String> {
match addr {
Addr::AttrVar(h) =>
Some(format!("_{}", h + 1)),
self.push_list();
},
HeapCellValue::Addr(addr) =>
- if let Some(offset_str) = self.offset_as_string(addr) {
+ if let Some(offset_str) = self.offset_as_string(iter, addr) {
push_space_if_amb!(self, &offset_str, {
self.append_str(offset_str.as_str());
})
Functor =.. [Name, Arg],
( Arg == true -> true
; Arg == false -> true
+ ; Name == variable_names -> must_be_var_names_list(Arg)
; var(Arg) -> throw(error(instantiation_error, write_term/2))
; throw(error(domain_error(write_option, Functor), write_term/2))
), % 8.14.2.3 e)
( Name == ignore_ops -> true
; Name == quoted -> true
; Name == numbervars -> true
+ ; Name == variable_names -> true
; throw(error(domain_error(write_option, Functor), write_term/2))
). % 8.14.2.3 e)
-inst_member_or([X|Xs], Y, _) :-
+inst_member_or([X|Xs], Y, Z) :-
( var(X) -> throw(error(instantiation_error, write_term/2))
- ; is_write_option(X) -> ( Y = X, ! ; inst_member_or(Xs, Y, _) )
+ ; is_write_option(X) -> ( Y = X, ! ; inst_member_or(Xs, Y, Z) )
; throw(error(domain_error(write_option, X), write_term/2))
).
inst_member_or([], Y, Y).
+must_be_var_names_list(VarNames) :-
+ '$skip_max_list'(_, -1, VarNames, Tail),
+ ( Tail == [] -> must_be_var_names_list_(VarNames)
+ ; var(Tail) -> throw(error(instantiation_error, write_term/2))
+ ; throw(error(domain_error(write_options, variable_names(VarNames)), write_term/2))
+ ).
+
+must_be_var_names_list_([]).
+must_be_var_names_list_([VarName | VarNames]) :-
+ ( nonvar(VarName), VarName = (Atom = _) ->
+ ( atom(Atom) -> must_be_var_names_list_(VarNames)
+ ; var(Atom) -> throw(error(instantiation_error, write_term/2))
+ ; throw(error(domain_error(write_options, variable_names(VarName)), write_term/2))
+ )
+ ; throw(error(instantiation_error, write_term/2))
+ ).
+
write_term(_, Options) :-
var(Options), throw(error(instantiation_error, write_term/2)).
write_term(Term, Options) :-
inst_member_or(Options, ignore_ops(IgnoreOps), ignore_ops(false)),
inst_member_or(Options, numbervars(NumberVars), numbervars(false)),
inst_member_or(Options, quoted(Quoted), quoted(false)),
- '$write_term'(Term, IgnoreOps, NumberVars, Quoted).
+ inst_member_or(Options, variable_names(VarNames), variable_names([])),
+ '$write_term'(Term, IgnoreOps, NumberVars, Quoted, VarNames).
write(Term) :- write_term(Term, [numbervars(true)]).
( var(Name) -> throw(error(instantiation_error, abolish/1))
; integer(Arity) ->
( \+ atom(Name) -> throw(error(type_error(atom, Name), abolish/1))
- ; Arity < 0 -> throw(domain_error(not_less_than_zero, Arity), abolish/1)
- ; max_arity(N), Arity > N -> throw(representation_error(max_arity), abolish/1)
+ ; Arity < 0 -> throw(error(domain_error(not_less_than_zero, Arity), abolish/1))
+ ; max_arity(N), Arity > N -> throw(error(representation_error(max_arity), abolish/1))
; functor(Head, Name, Arity) ->
( '$module_head_is_dynamic'(Head, Module) ->
'$abolish_module_clause'(Name, Arity, Module)
; var(Arity) -> throw(error(instantiation_error, abolish/1))
; integer(Arity) ->
( \+ atom(Name) -> throw(error(type_error(atom, Name), abolish/1))
- ; Arity < 0 -> throw(domain_error(not_less_than_zero, Arity), abolish/1)
- ; max_arity(N), Arity > N -> throw(representation_error(max_arity), abolish/1)
+ ; Arity < 0 -> throw(error(domain_error(not_less_than_zero, Arity), abolish/1))
+ ; max_arity(N), Arity > N -> throw(error(representation_error(max_arity), abolish/1))
; functor(Head, Name, Arity) ->
( '$no_such_predicate'(Head) -> true
; '$head_is_dynamic'(Head) -> '$abolish_clause'(Name, Arity)
attr_vars.into_iter()
}
- fn populate_project_attr_lists(&mut self, var_dict: &HeapVarDict) -> (Addr, Addr)
+ fn populate_project_attr_lists(&mut self) -> (Addr, Addr)
{
let mut query_vars = HashSet::new();
let attr_vars = self.gather_attr_vars_created_since(0);
- for (_, addr) in var_dict {
+ for (_, addr) in self.heap_locs.iter() {
let iter = self.acyclic_pre_order_iter(addr.clone());
for value in iter {
self.p = CodePtr::Local(LocalCodePtr::DirEntry(p));
}
- fn print_attribute_goals_string(&mut self, op_dir: &OpDir, var_dict: &HeapVarDict) -> String
+ fn print_attribute_goals_string(&mut self, op_dir: &OpDir) -> String
{
let mut attr_goals = mem::replace(&mut self.attr_var_init.attribute_goals, vec![]);
let mut output = PrinterOutputter::new();
for goal_addr in attr_goals {
- let mut printer = HCPrinter::from_heap_locs(&self, op_dir, output, var_dict);
+ let mut printer = HCPrinter::from_heap_locs(&self, op_dir, output);
printer.see_all_locs();
printer.numbervars = false;
impl Machine {
pub
- fn attribute_goals(&mut self, var_dict: &HeapVarDict) -> String
+ fn attribute_goals(&mut self) -> String
{
let p = self.machine_st.attr_var_init.project_attrs_loc;
- let (query_vars, attr_vars) = self.machine_st.populate_project_attr_lists(var_dict);
+ let (query_vars, attr_vars) = self.machine_st.populate_project_attr_lists();
self.machine_st.allocate(0);
self.machine_st.query_stepper(&mut self.indices, &mut self.policies, &mut self.code_repo,
&mut readline::input_stream());
- self.machine_st.print_attribute_goals_string(&self.indices.op_dir, var_dict)
+ self.machine_st.print_attribute_goals_string(&self.indices.op_dir)
}
}
pub enum EvalSession {
EntrySuccess,
Error(SessionError),
- InitialQuerySuccess(AllocVarDict, HeapVarDict),
+ InitialQuerySuccess(AllocVarDict),
QueryFailure,
SubsequentQuerySuccess,
}
pub(super) lifted_heap: Vec<HeapCellValue>,
pub(super) interms: Vec<Number>, // intermediate numbers.
pub(super) last_call: bool,
+ pub(crate) heap_locs: HeapVarDict,
pub(crate) flags: MachineFlags
}
lifted_heap: Vec::with_capacity(1024),
interms: vec![Number::default(); 256],
last_call: false,
+ heap_locs: HeapVarDict::new(),
flags: MachineFlags::default()
}
}
lifted_heap: Vec::with_capacity(capacity),
interms: vec![Number::default(); 0],
last_call: false,
+ heap_locs: HeapVarDict::new(),
flags: MachineFlags::default()
}
}
}
pub(super)
- fn print_var_eq<Outputter>(&self, var: Rc<Var>, addr: Addr, op_dir: &OpDir, var_dict: &HeapVarDict,
- mut output: Outputter)
+ fn print_var_eq<Outputter>(&self, var: Rc<Var>, addr: Addr, op_dir: &OpDir, mut output: Outputter)
-> Outputter
where Outputter: HCValueOutputter
{
output.append(var.as_str());
output.append(" = ");
- let mut printer = HCPrinter::from_heap_locs(&self, op_dir, output, var_dict);
+ let mut printer = HCPrinter::from_heap_locs(&self, op_dir, output);
printer.numbervars = false;
printer.quoted = true;
self.block = 0;
self.ball.reset();
+ self.heap_locs.clear();
self.lifted_heap.clear();
}
pub fn run_toplevel(&mut self) {
self.machine_st.p = CodePtr::Local(LocalCodePtr::DirEntry(self.toplevel_idx));
- self.run_query(&AllocVarDict::new(), &mut HeapVarDict::new());
+ self.run_query(&AllocVarDict::new());
}
pub fn new(prolog_stream: PrologStream) -> Self {
pub fn submit_query(&mut self, code: Code, alloc_locs: AllocVarDict) -> EvalSession
{
- let mut heap_locs = HeapVarDict::new();
-
self.code_repo.cached_query = code;
- self.run_query(&alloc_locs, &mut heap_locs);
+ self.run_query(&alloc_locs);
if self.machine_st.fail {
EvalSession::QueryFailure
} else {
- EvalSession::InitialQuerySuccess(alloc_locs, heap_locs)
- }
- }
-
- fn record_var_places(&self, chunk_num: usize, alloc_locs: &AllocVarDict,
- heap_locs: &mut HeapVarDict)
- {
- for (var, var_data) in alloc_locs {
- match var_data {
- &VarData::Perm(p) if p > 0 =>
- if !heap_locs.contains_key(var) {
- let e = self.machine_st.e;
- let r = var_data.as_reg_type().reg_num();
- let addr = self.machine_st.and_stack[e][r].clone();
-
- heap_locs.insert(var.clone(), addr);
- },
- &VarData::Temp(cn, _, _) if cn == chunk_num => {
- let r = var_data.as_reg_type();
-
- if r.reg_num() != 0 {
- let addr = self.machine_st[r].clone();
- heap_locs.insert(var.clone(), addr);
- }
- },
- _ => {}
- }
+ EvalSession::InitialQuerySuccess(alloc_locs)
}
}
};
}
- let term_output = self.machine_st.print_query(term, &self.indices.op_dir,
- &var_dict);
+ self.machine_st.heap_locs = var_dict;
+ let term_output = self.machine_st.print_query(term, &self.indices.op_dir);
+
term_output.result()
},
Err(err_stub) => {
fn handle_eval_session(&mut self, result: EvalSession, snapshot: MachineState) {
match result {
- EvalSession::InitialQuerySuccess(alloc_locs, mut heap_locs) =>
+ EvalSession::InitialQuerySuccess(alloc_locs) =>
loop {
let bindings = {
let mut output = PrinterOutputter::new();
- self.toplevel_heap_view(&heap_locs, output).result()
+ self.toplevel_heap_view(output).result()
};
- let attr_goals = self.attribute_goals(&heap_locs);
+ let attr_goals = self.attribute_goals();
if !(self.machine_st.b > 0) {
if bindings.is_empty() {
let result = match next_keypress() {
ContinueResult::ContinueQuery => {
write!(raw_stdout, " ;\r\n").unwrap();
- self.continue_query(&alloc_locs, &mut heap_locs)
+ self.continue_query(&alloc_locs)
},
ContinueResult::Conclude => {
write!(raw_stdout, " ...\r\n").unwrap();
}
pub(super)
- fn run_query(&mut self, alloc_locs: &AllocVarDict, heap_locs: &mut HeapVarDict)
+ fn run_query(&mut self, alloc_locs: &AllocVarDict)
{
let end_ptr = top_level_code_ptr!(0, self.code_repo.size_of_cached_query());
if let CodePtr::Local(LocalCodePtr::TopLevel(mut cn, p)) = self.machine_st.p {
match &self.code_repo[LocalCodePtr::TopLevel(cn, p)] {
&Line::Control(ref ctrl_instr) if ctrl_instr.is_jump_instr() => {
- self.record_var_places(cn, alloc_locs, heap_locs);
+ self.machine_st.record_var_places(cn, alloc_locs);
cn += 1;
},
_ => {}
self.dynamic_transaction(trans_type, p);
if let CodePtr::Local(LocalCodePtr::TopLevel(_, 0)) = self.machine_st.p {
- if heap_locs.is_empty() {
- self.record_var_places(0, alloc_locs, heap_locs);
+ if self.machine_st.heap_locs.is_empty() {
+ self.machine_st.record_var_places(0, alloc_locs);
}
self.code_repo.cached_query = cached_query;
self.code_repo.cached_query = cached_query;
},
_ => {
- if heap_locs.is_empty() {
- self.record_var_places(0, alloc_locs, heap_locs);
+ if self.machine_st.heap_locs.is_empty() {
+ self.machine_st.record_var_places(0, alloc_locs);
}
break;
}
}
- pub fn continue_query(&mut self, alloc_l: &AllocVarDict, heap_l: &mut HeapVarDict) -> EvalSession
+ pub fn continue_query(&mut self, alloc_locs: &AllocVarDict) -> EvalSession
{
if !self.or_stack_is_empty() {
let b = self.machine_st.b - 1;
return EvalSession::QueryFailure;
}
- self.run_query(alloc_l, heap_l);
+ self.run_query(alloc_locs);
if self.machine_st.fail {
EvalSession::QueryFailure
}
}
- pub fn toplevel_heap_view<Outputter>(&self, var_dir: &HeapVarDict, mut output: Outputter) -> Outputter
+ pub fn toplevel_heap_view<Outputter>(&self, mut output: Outputter) -> Outputter
where Outputter: HCValueOutputter
{
- let mut sorted_vars: Vec<_> = var_dir.iter().collect();
+ let mut sorted_vars: Vec<_> = self.machine_st.heap_locs.iter().collect();
sorted_vars.sort_by_key(|ref v| v.0);
for (var, addr) in sorted_vars {
let addr = self.machine_st.store(self.machine_st.deref(addr.clone()));
- output = self.machine_st.print_var_eq(var.clone(), addr, &self.indices.op_dir, var_dir,
+ output = self.machine_st.print_var_eq(var.clone(), addr, &self.indices.op_dir,
output);
}
}
#[cfg(test)]
- pub fn test_heap_view<Outputter>(&self, var_dir: &HeapVarDict, mut output: Outputter)
- -> Outputter
+ pub fn test_heap_view<Outputter>(&self, mut output: Outputter) -> Outputter
where Outputter: HCValueOutputter
{
- let mut sorted_vars: Vec<(&Rc<Var>, &Addr)> = var_dir.iter().collect();
+ let mut sorted_vars: Vec<(&Rc<Var>, &Addr)> = self.machine_st.heap_locs.iter().collect();
sorted_vars.sort_by_key(|ref v| v.0);
for (var, addr) in sorted_vars {
output = self.machine_st.print_var_eq(var.clone(), addr.clone(), &self.indices.op_dir,
- var_dir, output);
+ output);
}
output
impl MachineState {
- fn print_query(&mut self, addr: Addr, op_dir: &OpDir, var_dict: &HeapVarDict) -> PrinterOutputter
+ fn record_var_places(&mut self, chunk_num: usize, alloc_locs: &AllocVarDict)
+ {
+ for (var, var_data) in alloc_locs {
+ match var_data {
+ &VarData::Perm(p) if p > 0 =>
+ if !self.heap_locs.contains_key(var) {
+ let e = self.e;
+ let r = var_data.as_reg_type().reg_num();
+ let addr = self.and_stack[e][r].clone();
+
+ self.heap_locs.insert(var.clone(), addr);
+ },
+ &VarData::Temp(cn, _, _) if cn == chunk_num => {
+ let r = var_data.as_reg_type();
+
+ if r.reg_num() != 0 {
+ let addr = self[r].clone();
+ self.heap_locs.insert(var.clone(), addr);
+ }
+ },
+ _ => {}
+ }
+ }
+ }
+
+ fn print_query(&mut self, addr: Addr, op_dir: &OpDir) -> PrinterOutputter
{
let flags = self.flags;
self.flags = MachineFlags { double_quotes: DoubleQuotes::Atom };
let output = PrinterOutputter::new();
- let mut printer = HCPrinter::from_heap_locs(&self, op_dir, output, var_dict);
+ let mut printer = HCPrinter::from_heap_locs(&self, op_dir, output);
printer.quoted = true;
printer.numbervars = false;
use ref_thread_local::RefThreadLocal;
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
use std::io::{stdout, Write};
use std::iter::once;
use std::mem;
-> CallResult
{
let nx = self[temp_v!(2)].clone();
-
+
if let Some(c) = string.chars().last() {
if layout_char!(c) {
let err = ParserError::UnexpectedChar(c);
self.unify(a2, Addr::Con(Constant::Number(len)));
},
- &SystemClauseType::CharsToNumber => {
+ &SystemClauseType::CharsToNumber => {
let stub = MachineError::functor_stub(clause_name!("number_chars"), 2);
match self.try_from_list(temp_v!(1), stub.clone()) {
let char_list = Addr::HeapCell(self.heap.to_list(chars));
self.unify(char_list, chs);
- },
+ },
&SystemClauseType::NumberToCodes => {
let n = self[temp_v!(1)].clone();
let chs = self[temp_v!(2)].clone();
printer.quoted = name.as_str() == "true";
}
+ let stub = MachineError::functor_stub(clause_name!("write_term"), 2);
+
+ match self.try_from_list(temp_v!(5), stub.clone()) {
+ Ok(addrs) => {
+ let mut var_names: HashMap<Addr, String> = HashMap::new();
+
+ for addr in addrs {
+ match addr {
+ Addr::Str(s) =>
+ match &self.heap[s] {
+ &HeapCellValue::NamedStr(2, ref name, _)
+ if name.as_str() == "=" => {
+ let atom = self.heap[s+1].as_addr(s+1);
+ let var = self.heap[s+2].as_addr(s+2);
+
+ let atom = match self.store(self.deref(atom)) {
+ Addr::Con(Constant::Atom(atom, _)) => atom.to_string(),
+ Addr::Con(Constant::Char(c)) => c.to_string(),
+ _ => unreachable!()
+ };
+
+ let var = self.store(self.deref(var));
+
+ if var_names.contains_key(&var) {
+ continue;
+ }
+
+ var_names.insert(var, atom);
+ },
+ _ => unreachable!()
+ },
+ _ => unreachable!()
+ }
+ }
+
+ printer.var_names = var_names;
+ },
+ Err(err) =>
+ return Err(err)
+ }
+
let mut output = printer.print(addr);
print!("{}", output.result());
stdout().flush().unwrap();
impl MachineState {
pub(super)
- fn print_with_locs(&self, addr: Addr, op_dir: &OpDir, var_dict: &HeapVarDict) -> PrinterOutputter
+ fn print_with_locs(&self, addr: Addr, op_dir: &OpDir) -> PrinterOutputter
{
let output = PrinterOutputter::new();
- let mut printer = HCPrinter::from_heap_locs(&self, op_dir, output, var_dict);
+ let mut printer = HCPrinter::from_heap_locs(&self, op_dir, output);
let mut max_var_length = 0;
- for var in var_dict.keys() {
+ for var in self.heap_locs.keys() {
max_var_length = std::cmp::max(var.len(), max_var_length);
}
self.reset();
None
} else {
- let &TermWriteResult { heap_loc: _, ref var_dict } = &term_write_result;
- let output = self.print_with_locs(Addr::HeapCell(h), &indices.op_dir, var_dict);
+ let TermWriteResult { var_dict, .. } = term_write_result;
+
+ self.heap_locs = var_dict;
+ let output = self.print_with_locs(Addr::HeapCell(h), &indices.op_dir);
self.reset();
Some(output.result())
}
}
-pub fn collect_test_output(wam: &mut Machine, alloc_locs: AllocVarDict, mut heap_locs: HeapVarDict)
- -> Vec<HashSet<String>>
+pub fn collect_test_output(wam: &mut Machine, alloc_locs: AllocVarDict) -> Vec<HashSet<String>>
{
let mut output = TestOutputter::new();
- output = wam.test_heap_view(&heap_locs, output);
+ output = wam.test_heap_view(output);
output.cache();
- while let EvalSession::SubsequentQuerySuccess = wam.continue_query(&alloc_locs, &mut heap_locs)
- {
- output = wam.test_heap_view(&heap_locs, output);
+ while let EvalSession::SubsequentQuerySuccess = wam.continue_query(&alloc_locs) {
+ output = wam.test_heap_view(output);
output.cache();
}
output.result()
}
-pub fn collect_test_output_with_limit(wam: &mut Machine, alloc_locs: AllocVarDict,
- mut heap_locs: HeapVarDict, limit: usize)
+pub fn collect_test_output_with_limit(wam: &mut Machine, alloc_locs: AllocVarDict, limit: usize)
-> Vec<HashSet<String>>
{
let mut output = TestOutputter::new();
- output = wam.test_heap_view(&heap_locs, output);
+ output = wam.test_heap_view(output);
output.cache();
let mut count = 1;
return output.result();
}
- while let EvalSession::SubsequentQuerySuccess = wam.continue_query(&alloc_locs, &mut heap_locs)
+ while let EvalSession::SubsequentQuerySuccess = wam.continue_query(&alloc_locs)
{
- output = wam.test_heap_view(&heap_locs, output);
+ output = wam.test_heap_view(output);
output.cache();
count += 1;
wam.reset();
match submit_code(wam, buffer) {
- EvalSession::InitialQuerySuccess(_, _) |
+ EvalSession::InitialQuerySuccess(_) |
EvalSession::EntrySuccess |
EvalSession::SubsequentQuerySuccess =>
true,
match stream_to_toplevel(parsing_stream(buffer.as_bytes()), wam) {
Ok(term) =>
match compile_term(wam, term) {
- EvalSession::InitialQuerySuccess(alloc_locs, heap_locs) =>
- result == collect_test_output(wam, alloc_locs, heap_locs),
+ EvalSession::InitialQuerySuccess(alloc_locs) =>
+ result == collect_test_output(wam, alloc_locs),
EvalSession::EntrySuccess => true,
_ => false
},
match stream_to_toplevel(parsing_stream(buffer.as_bytes()), wam) {
Ok(term) =>
match compile_term(wam, term) {
- EvalSession::InitialQuerySuccess(alloc_locs, heap_locs) =>
- result == collect_test_output_with_limit(wam, alloc_locs,
- heap_locs, limit),
+ EvalSession::InitialQuerySuccess(alloc_locs) =>
+ result == collect_test_output_with_limit(wam, alloc_locs, limit),
EvalSession::EntrySuccess => true,
_ => false
},
submit(&mut wam, ":- use_module(library(non_iso)).");
- assert_prolog_success!(&mut wam, "call_with_inference_limit((setup_call_cleanup(S=1,(G=2;fail),writeq(S+G>B)),B=3,!),100,R).",
+ assert_prolog_success!(&mut wam, "call_with_inference_limit((setup_call_cleanup(S=1,(G=2;fail),writeq(S+G>B)),B=3,!),135,R).",
[["G = 2","B = 3","R = !","S = 1"]]);
assert_prolog_success!(&mut wam, "call_with_inference_limit((setup_call_cleanup(S=1,(G=2;fail),writeq(S+G>B)),B=3,!),10,R).",
[["S = _1","G = _4","B = _14","R = inference_limit_exceeded"]]);
projects / scryer-prolog.git / commitdiff