From 3912a4772d38658ed8dece5c0b60a8978d6c9b4a Mon Sep 17 00:00:00 2001 From: Mark Thom Date: Thu, 4 Apr 2019 22:51:00 -0600 Subject: [PATCH] fix conformity errors --- Cargo.toml | 2 +- src/prolog/arithmetic.rs | 4 +- src/prolog/clause_types.rs | 18 +++-- src/prolog/forms.rs | 56 ++++++--------- src/prolog/heap_print.rs | 90 ++++++++++++++---------- src/prolog/iterators.rs | 13 ++-- src/prolog/machine/compile.rs | 23 +++--- src/prolog/machine/copier.rs | 2 +- src/prolog/machine/machine_errors.rs | 6 +- src/prolog/machine/machine_indices.rs | 16 ++--- src/prolog/machine/machine_state.rs | 6 +- src/prolog/machine/machine_state_impl.rs | 13 ++-- src/prolog/machine/mod.rs | 8 +-- src/prolog/machine/modules.rs | 11 ++- src/prolog/machine/system_calls.rs | 8 +-- src/prolog/machine/toplevel.rs | 16 ++--- src/prolog/write.rs | 6 +- 17 files changed, 149 insertions(+), 149 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 91301c69..7f3688c9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,7 +14,7 @@ cfg-if = "0.1.7" downcast = "0.10.0" num = "0.2" ordered-float = "0.5.0" -prolog_parser = "0.8.14" +prolog_parser = "0.8.15" readline_rs_compat = { version = "0.1.7", optional = true } ref_thread_local = "0.0.0" diff --git a/src/prolog/arithmetic.rs b/src/prolog/arithmetic.rs index d5e5246c..09a3042d 100644 --- a/src/prolog/arithmetic.rs +++ b/src/prolog/arithmetic.rs @@ -28,8 +28,8 @@ impl<'a> ArithInstructionIterator<'a> { let state = match term { &Term::AnonVar => return Err(ArithmeticError::InvalidTerm), - &Term::Clause(ref cell, ref name, ref terms, fixity) => - match ClauseType::from(name.clone(), terms.len(), fixity) { + &Term::Clause(ref cell, ref name, ref terms, ref fixity) => + match ClauseType::from(name.clone(), terms.len(), fixity.clone()) { ct @ ClauseType::Named(..) | ct @ ClauseType::Op(..) => Ok(TermIterState::Clause(Level::Shallow, 0, cell, ct, terms)), _ => Err(ArithmeticError::InvalidOp) diff --git a/src/prolog/clause_types.rs b/src/prolog/clause_types.rs index 82b57c45..1252a77a 100644 --- a/src/prolog/clause_types.rs +++ b/src/prolog/clause_types.rs @@ -1,6 +1,5 @@ use prolog_parser::ast::*; -use prolog::forms::OpDecl; use prolog::machine::machine_indices::*; use ref_thread_local::RefThreadLocal; @@ -403,7 +402,7 @@ pub enum ClauseType { Hook(CompileTimeHook), Inlined(InlinedClauseType), Named(ClauseName, usize, CodeIndex), // name, arity, index. - Op(OpDecl, CodeIndex), + Op(ClauseName, SharedOpDesc, CodeIndex), System(SystemClauseType) } @@ -454,16 +453,16 @@ impl BuiltInClauseType { } impl ClauseType { - pub fn spec(&self) -> Option<(usize, Specifier)> { + pub fn spec(&self) -> Option { match self { - &ClauseType::Op(ref op_decl, _) => - Some((op_decl.0, op_decl.1)), + &ClauseType::Op(_, ref spec, _) => + Some(spec.clone()), &ClauseType::Inlined(InlinedClauseType::CompareNumber(..)) | &ClauseType::BuiltIn(BuiltInClauseType::Is(..)) | &ClauseType::BuiltIn(BuiltInClauseType::CompareTerm(_)) | &ClauseType::BuiltIn(BuiltInClauseType::NotEq) | &ClauseType::BuiltIn(BuiltInClauseType::Eq) => - Some((700, XFX)), + Some(SharedOpDesc::new(700, XFX)), _ => None } } @@ -474,21 +473,20 @@ impl ClauseType { &ClauseType::BuiltIn(ref built_in) => built_in.name(), &ClauseType::Hook(ref hook) => hook.name(), &ClauseType::Inlined(ref inlined) => clause_name!(inlined.name()), - &ClauseType::Op(ref op_decl, ..) => op_decl.name(), + &ClauseType::Op(ref name, ..) => name.clone(), &ClauseType::Named(ref name, ..) => name.clone(), &ClauseType::System(ref system) => system.name(), } } - pub fn from(name: ClauseName, arity: usize, spec: Option<(usize, Specifier)>) -> Self { + pub fn from(name: ClauseName, arity: usize, spec: Option) -> Self { CLAUSE_TYPE_FORMS.borrow().get(&(name.as_str(), arity)).cloned() .unwrap_or_else(|| SystemClauseType::from(name.as_str(), arity) .map(ClauseType::System) .unwrap_or_else(|| if let Some(spec) = spec { - let op_decl = OpDecl(spec.0, spec.1, name); - ClauseType::Op(op_decl, CodeIndex::default()) + ClauseType::Op(name, spec, CodeIndex::default()) } else if name.as_str() == "call" { ClauseType::CallN } else { diff --git a/src/prolog/forms.rs b/src/prolog/forms.rs index 04f48899..2a994391 100644 --- a/src/prolog/forms.rs +++ b/src/prolog/forms.rs @@ -177,30 +177,31 @@ impl OpDecl { self.2.clone() } - pub fn arity(&self) -> usize { - let spec = self.1; - - if (spec | XFX != 0) || (spec | XFY != 0) || (spec | YFX != 0) { - 2 - } else { - 1 - } - } - + #[inline] pub fn remove(&self, op_dir: &mut OpDir) { + self.insert_into_op_dir(clause_name!(""), op_dir, 0); + } + + fn insert_into_op_dir(&self, module: ClauseName, op_dir: &mut OpDir, prec: usize) + { let (spec, name) = (self.1, self.2.clone()); - if is_prefix!(spec) { - op_dir.remove(&(name.clone(), Fixity::Pre)); - } + let fixity = match spec { + XFY | XFX | YFX => Fixity::In, + XF | YF => Fixity::Post, + FX | FY => Fixity::Pre, + _ => return + }; - if is_infix!(spec) { - op_dir.remove(&(name.clone(), Fixity::In)); + match op_dir.get(&(name.clone(), fixity)) { + Some(cell) => { + cell.shared_op_desc().set(prec, spec); + return; + } + None => {} } - if is_postfix!(spec) { - op_dir.remove(&(name, Fixity::Post)); - } + op_dir.insert((name, fixity), OpDirValue::new(spec, prec, module)); } pub fn submit(&self, module: ClauseName, existing_desc: Option, op_dir: &mut OpDir) @@ -213,7 +214,7 @@ impl OpDecl { if desc.post > 0 { return Err(SessionError::OpIsInfixAndPostFix(name)); } - }; + } } if is_postfix!(spec) { @@ -221,23 +222,10 @@ impl OpDecl { if desc.inf > 0 { return Err(SessionError::OpIsInfixAndPostFix(name)); } - }; + } } - match spec { - XFY | XFX | YFX => { - op_dir.insert((name.clone(), Fixity::In), (spec, prec, module.clone())); - }, - XF | YF => { - op_dir.insert((name.clone(), Fixity::Post), (spec, prec, module.clone())); - }, - FX | FY => { - op_dir.insert((name.clone(), Fixity::Pre), (spec, prec, module.clone())); - }, - _ => {} - }; - - Ok(()) + Ok(self.insert_into_op_dir(module, op_dir, prec)) } } diff --git a/src/prolog/heap_print.rs b/src/prolog/heap_print.rs index c7ef60ed..b6b93e77 100644 --- a/src/prolog/heap_print.rs +++ b/src/prolog/heap_print.rs @@ -17,8 +17,8 @@ use std::rc::Rc; /* contains the location, name, precision and Specifier of the parent op. */ #[derive(Clone)] pub enum DirectedOp { - Left(ClauseName, (usize, Specifier)), - Right(ClauseName, (usize, Specifier)), + Left(ClauseName, SharedOpDesc), + Right(ClauseName, SharedOpDesc) } impl DirectedOp { @@ -33,22 +33,33 @@ impl DirectedOp { #[inline] fn is_negative_sign(&self) -> bool { match self { - &DirectedOp::Left(ref name, (_, spec)) | &DirectedOp::Right(ref name, (_, spec)) => - name.as_str() == "-" && is_prefix!(spec) + &DirectedOp::Left(ref name, ref cell) | &DirectedOp::Right(ref name, ref cell) => + name.as_str() == "-" && is_prefix!(cell.assoc()) } } } -fn needs_bracketing(child_spec: (usize, Specifier), op: &DirectedOp) -> bool +fn needs_bracketing(child_spec: &SharedOpDesc, op: &DirectedOp) -> bool { match op { - &DirectedOp::Left(_, (priority, spec)) => { + &DirectedOp::Left(ref name, ref cell) => { + let (priority, spec) = cell.get(); + + if name.as_str() == "-" { + let child_assoc = child_spec.assoc(); + if is_prefix!(spec) && (is_postfix!(child_assoc) || is_infix!(child_assoc)) { + return true; + } + } + let is_strict_right = is_yfx!(spec) || is_xfx!(spec) || is_fx!(spec); - child_spec.0 > priority || (child_spec.0 == priority && is_strict_right) + child_spec.prec() > priority || (child_spec.prec() == priority && is_strict_right) }, - &DirectedOp::Right(_, (priority, spec)) => { + &DirectedOp::Right(_, ref cell) => { + let (priority, spec) = cell.get(); let is_strict_left = is_xfx!(spec) || is_xfy!(spec) || is_xf!(spec); - child_spec.0 > priority || (child_spec.0 == priority && is_strict_left) + + child_spec.prec() > priority || (child_spec.prec() == priority && is_strict_left) } } } @@ -66,19 +77,19 @@ impl<'a> HCPreOrderIterator<'a> { None => return false }; - let mut parent_spec = DirectedOp::Left(clause_name!("-"), (200, FY)); + let mut parent_spec = DirectedOp::Left(clause_name!("-"), SharedOpDesc::new(200, FY)); loop { match self.machine_st.store(self.machine_st.deref(addr)) { Addr::Str(s) => match &self.machine_st.heap[s] { - &HeapCellValue::NamedStr(_, ref name, Some(spec)) - if is_postfix!(spec.1) || is_infix!(spec.1) => + &HeapCellValue::NamedStr(_, ref name, Some(ref spec)) + if is_postfix!(spec.assoc()) || is_infix!(spec.assoc()) => if needs_bracketing(spec, &parent_spec) { return false; } else { addr = Addr::HeapCell(s+1); - parent_spec = DirectedOp::Right(name.clone(), spec); + parent_spec = DirectedOp::Right(name.clone(), spec.clone()); }, _ => return false @@ -95,7 +106,7 @@ impl<'a> HCPreOrderIterator<'a> { #[derive(Clone)] pub enum TokenOrRedirect { Atom(ClauseName), - Op(ClauseName, (usize, Specifier)), + Op(ClauseName, SharedOpDesc), NumberedVar(String), CompositeRedirect(DirectedOp), FunctorRedirect, @@ -259,7 +270,7 @@ fn continues_with_append(atom: &str, op: &str) -> bool { if alpha_char!(ac) { alpha_numeric_char!(oc) } else if graphic_token_char!(ac) { - graphic_char!(oc) + graphic_token_char!(oc) } else if variable_indicator_char!(ac) { alpha_numeric_char!(oc) } else if capital_letter_char!(ac) { @@ -354,7 +365,7 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> { let mut printer = Self::new(machine_st, output); - printer.toplevel_spec = Some(DirectedOp::Right(clause_name!("="), (700, XFX))); + printer.toplevel_spec = Some(DirectedOp::Right(clause_name!("="), SharedOpDesc::new(700, XFX))); printer.heap_locs = reverse_heap_locs(machine_st, heap_locs); printer @@ -375,25 +386,25 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> } // TODO: create a DirectedOp factory method. Use it here, and above. - fn enqueue_op(&mut self, ct: ClauseType, spec: (usize, Specifier)) { - if is_postfix!(spec.1) { - let right_directed_op = DirectedOp::Right(ct.name(), spec); + fn enqueue_op(&mut self, ct: ClauseType, spec: SharedOpDesc) { + if is_postfix!(spec.assoc()) { + let right_directed_op = DirectedOp::Right(ct.name(), spec.clone()); self.state_stack.push(TokenOrRedirect::Op(ct.name(), spec)); self.state_stack.push(TokenOrRedirect::CompositeRedirect(right_directed_op)); - } else if is_prefix!(spec.1) { + } else if is_prefix!(spec.assoc()) { if ct.name().as_str() == "-" { - self.format_negated_operand(); + self.format_negated_operand(spec); return; } - let left_directed_op = DirectedOp::Left(ct.name(), spec); + let left_directed_op = DirectedOp::Left(ct.name(), spec.clone()); self.state_stack.push(TokenOrRedirect::CompositeRedirect(left_directed_op)); self.state_stack.push(TokenOrRedirect::Op(ct.name(), spec)); - } else { // if is_infix!(spec.1) - let left_directed_op = DirectedOp::Left(ct.name(), spec); - let right_directed_op = DirectedOp::Right(ct.name(), spec); + } else { // if is_infix!(spec.assoc()) + let left_directed_op = DirectedOp::Left(ct.name(), spec.clone()); + let right_directed_op = DirectedOp::Right(ct.name(), spec.clone()); self.state_stack.push(TokenOrRedirect::CompositeRedirect(left_directed_op)); self.state_stack.push(TokenOrRedirect::Op(ct.name(), spec)); @@ -416,10 +427,10 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> self.state_stack.push(TokenOrRedirect::Atom(name)); } - fn format_negated_operand(&mut self) + fn format_negated_operand(&mut self, spec: SharedOpDesc) { - let op = DirectedOp::Left(clause_name!("-"), (200, FY)); - + let op = DirectedOp::Left(clause_name!("-"), spec); + self.state_stack.push(TokenOrRedirect::CompositeRedirect(op)); self.state_stack.push(TokenOrRedirect::Space); self.state_stack.push(TokenOrRedirect::Atom(clause_name!("-"))); @@ -452,10 +463,17 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> if self.format_numbered_vars(iter) { return; } - } - + } + if let Some(spec) = ct.spec() { - if !self.ignore_ops { + if "." == ct.name().as_str() && is_infix!(spec.assoc()) { + if !self.ignore_ops { + self.push_list(); + return; + } + } + + if !self.ignore_ops && spec.prec() > 0 { return self.enqueue_op(ct, spec); } } @@ -628,10 +646,10 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> if self.outputter.ends_with(&format!(" {}", op.as_str())) { self.push_char(' '); } - + self.push_char('('); } - + self.print_atom(atom); if op.is_some() { @@ -715,12 +733,12 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> }; match heap_val { - HeapCellValue::NamedStr(arity, ref name, Some(spec)) => { + HeapCellValue::NamedStr(arity, name, Some(spec)) => { let add_brackets = if !self.ignore_ops { add_brackets || if let Some(ref op) = &op { - needs_bracketing(spec, op) + needs_bracketing(&spec, op) } else { - is_functor_redirect && spec.0 >= 1000 + is_functor_redirect && spec.prec() >= 1000 } } else { false diff --git a/src/prolog/iterators.rs b/src/prolog/iterators.rs index ce815249..4c9c863a 100644 --- a/src/prolog/iterators.rs +++ b/src/prolog/iterators.rs @@ -45,10 +45,9 @@ impl<'a> TermIterState<'a> { match term { &Term::AnonVar => TermIterState::AnonVar(lvl), - &Term::Clause(ref cell, ref name, ref subterms, spec) => { + &Term::Clause(ref cell, ref name, ref subterms, ref spec) => { let ct = if let Some(spec) = spec { - let op_decl = OpDecl(spec.0, spec.1, name.clone()); - ClauseType::Op(op_decl, CodeIndex::default()) + ClauseType::Op(name.clone(), spec.clone(), CodeIndex::default()) } else { ClauseType::Named(name.clone(), subterms.len(), CodeIndex::default()) }; @@ -86,9 +85,9 @@ impl<'a> QueryIterator<'a> { let state = match term { &Term::AnonVar => return QueryIterator { state_stack: vec![] }, - &Term::Clause(ref r, ref name, ref terms, fixity) => + &Term::Clause(ref r, ref name, ref terms, ref fixity) => TermIterState::Clause(Level::Root, 0, r, - ClauseType::from(name.clone(), terms.len(), fixity), + ClauseType::from(name.clone(), terms.len(), fixity.clone()), terms), &Term::Cons(..) => return QueryIterator { state_stack: vec![] }, @@ -200,8 +199,8 @@ impl<'a> FactIterator<'a> { let states = match term { &Term::AnonVar => vec![TermIterState::AnonVar(Level::Root)], - &Term::Clause(ref cell, ref name, ref terms, fixity) => { - let ct = ClauseType::from(name.clone(), terms.len(), fixity); + &Term::Clause(ref cell, ref name, ref terms, ref fixity) => { + let ct = ClauseType::from(name.clone(), terms.len(), fixity.clone()); vec![TermIterState::Clause(Level::Root, 0, cell, ct, terms)] }, &Term::Cons(ref cell, ref head, ref tail) => diff --git a/src/prolog/machine/compile.rs b/src/prolog/machine/compile.rs index 8b7c6d76..559985fb 100644 --- a/src/prolog/machine/compile.rs +++ b/src/prolog/machine/compile.rs @@ -395,8 +395,8 @@ impl ListingCompiler { if ct_name == &name && arity == ct_arity => { *idx = self_idx.clone(); }, - &mut ClauseType::Op(ref op_decl, ref mut idx) - if op_decl.name() == name && op_decl.arity() == arity => { + &mut ClauseType::Op(ref op_name, ref shared_op_desc, ref mut idx) + if op_name == &name && shared_op_desc.arity() == arity => { *idx = self_idx.clone(); }, _ => {} @@ -553,14 +553,11 @@ impl ListingCompiler { Declaration::NonCountedBacktracking(name, arity) => Ok(self.add_non_counted_bt_flag(name, arity)), Declaration::Op(op_decl) => { - let existing_desc = { - let comp_ops = composite_op!(self.module.is_some(), &wam_indices.op_dir, - &mut indices.op_dir); + let spec = get_desc(op_decl.name(), composite_op!(self.module.is_some(), + &wam_indices.op_dir, + &mut indices.op_dir)); - get_desc(op_decl.name(), comp_ops) - }; - - op_decl.submit(self.get_module_name(), existing_desc, &mut indices.op_dir) + op_decl.submit(self.get_module_name(), spec, &mut indices.op_dir) }, Declaration::UseModule(name) => self.use_module(name, code_repo, flags, wam_indices, indices), @@ -579,10 +576,10 @@ impl ListingCompiler { } } - fn process_and_commit_decl<'a, R: Read>(&mut self, decl: Declaration, - worker: &mut TopLevelBatchWorker<'a, R>, - indices: &mut IndexStore, flags: MachineFlags) - -> Result<(), SessionError> + fn process_and_commit_decl(&mut self, decl: Declaration, + worker: &mut TopLevelBatchWorker, + indices: &mut IndexStore, flags: MachineFlags) + -> Result<(), SessionError> { match &decl { &Declaration::Dynamic(ref name, arity) => { diff --git a/src/prolog/machine/copier.rs b/src/prolog/machine/copier.rs index 7f87e937..5a9d0772 100644 --- a/src/prolog/machine/copier.rs +++ b/src/prolog/machine/copier.rs @@ -149,7 +149,7 @@ impl CopyTermState { self.target[addr] = HeapCellValue::Addr(Addr::Str(threshold)); self.trail.push((Ref::HeapCell(addr), - HeapCellValue::NamedStr(arity, name.clone(), fixity))); + HeapCellValue::NamedStr(arity, name.clone(), fixity.clone()))); self.target.push(HeapCellValue::NamedStr(arity, name, fixity)); diff --git a/src/prolog/machine/machine_errors.rs b/src/prolog/machine/machine_errors.rs index 8a72660d..02813de1 100644 --- a/src/prolog/machine/machine_errors.rs +++ b/src/prolog/machine/machine_errors.rs @@ -22,7 +22,7 @@ pub(super) struct MachineError { impl MachineError { pub(super) fn functor_stub(name: ClauseName, arity: usize) -> MachineStub { let name = HeapCellValue::Addr(Addr::Con(Constant::Atom(name, None))); - functor!("/", 2, [name, heap_integer!(arity)], (400, YFX)) + functor!("/", 2, [name, heap_integer!(arity)], SharedOpDesc::new(400, YFX)) } pub(super) fn evaluation_error(eval_error: EvalError) -> Self { @@ -47,8 +47,8 @@ impl MachineError { stub.append(&mut functor!("/", 2, [HeapCellValue::Addr(Addr::HeapCell(h + 2 + 3)), heap_integer!(arity)], - (400, YFX))); - stub.append(&mut functor!(":", 2, [mod_name, name], (600, XFY))); + SharedOpDesc::new(400, YFX))); + stub.append(&mut functor!(":", 2, [mod_name, name], SharedOpDesc::new(600, XFY))); MachineError { stub, from: ErrorProvenance::Constructed } } diff --git a/src/prolog/machine/machine_indices.rs b/src/prolog/machine/machine_indices.rs index 0ca9fa80..3b338818 100644 --- a/src/prolog/machine/machine_indices.rs +++ b/src/prolog/machine/machine_indices.rs @@ -14,8 +14,8 @@ use std::rc::Rc; #[derive(Clone, PartialEq, Eq, Hash)] pub enum DBRef { - BuiltInPred(ClauseName, usize, Option<(usize, Specifier)>), - NamedPred(ClauseName, usize, Option<(usize, Specifier)>) + BuiltInPred(ClauseName, usize, Option), + NamedPred(ClauseName, usize, Option) } #[derive(Clone, PartialEq, Eq, Hash)] @@ -163,7 +163,7 @@ impl From for TrailRef { #[derive(Clone, PartialEq)] pub enum HeapCellValue { Addr(Addr), - NamedStr(usize, ClauseName, Option<(usize, Specifier)>), // arity, name, precedence/Specifier if it has one. + NamedStr(usize, ClauseName, Option), // arity, name, precedence/Specifier if it has one. } impl HeapCellValue { @@ -411,7 +411,7 @@ pub struct IndexStore { impl IndexStore { pub fn predicate_exists(&self, name: ClauseName, module: ClauseName, arity: usize, - op_spec: Option<(usize, Specifier)>) + op_spec: Option) -> bool { match self.modules.get(&module) { @@ -419,8 +419,8 @@ impl IndexStore { match ClauseType::from(name, arity, op_spec) { ClauseType::Named(name, arity, _) => module.code_dir.contains_key(&(name, arity)), - ClauseType::Op(op_decl, ..) => - module.code_dir.contains_key(&(op_decl.name(), op_decl.arity())), + ClauseType::Op(name, spec, ..) => + module.code_dir.contains_key(&(name, spec.arity())), _ => true }, @@ -428,8 +428,8 @@ impl IndexStore { match ClauseType::from(name, arity, op_spec) { ClauseType::Named(name, arity, _) => self.code_dir.contains_key(&(name, arity)), - ClauseType::Op(op_decl, ..) => - self.code_dir.contains_key(&(op_decl.name(), op_decl.arity())), + ClauseType::Op(name, spec, ..) => + self.code_dir.contains_key(&(name, spec.arity())), _ => true } diff --git a/src/prolog/machine/machine_state.rs b/src/prolog/machine/machine_state.rs index f4d14b93..9ea77bc7 100644 --- a/src/prolog/machine/machine_state.rs +++ b/src/prolog/machine/machine_state.rs @@ -538,11 +538,11 @@ pub(crate) trait CallPolicy: Any { let c = match machine_st.compare_term_test(&a2, &a3) { Ordering::Greater => Addr::Con(Constant::Atom(clause_name!(">"), - Some((700, XFX)))), + Some(SharedOpDesc::new(700, XFX)))), Ordering::Equal => Addr::Con(Constant::Atom(clause_name!("="), - Some((700, XFX)))), + Some(SharedOpDesc::new(700, XFX)))), Ordering::Less => Addr::Con(Constant::Atom(clause_name!("<"), - Some((700, XFX)))) + Some(SharedOpDesc::new(700, XFX)))) }; machine_st.unify(a1, c); diff --git a/src/prolog/machine/machine_state_impl.rs b/src/prolog/machine/machine_state_impl.rs index 8aac7e2b..64212b95 100644 --- a/src/prolog/machine/machine_state_impl.rs +++ b/src/prolog/machine/machine_state_impl.rs @@ -1023,7 +1023,7 @@ impl MachineState { self.interms[t - 1] = try_or_fail!(self, self.pow(n1, n2)); self.p += 1; - }, + }, &ArithmeticInstruction::RDiv(ref a1, ref a2, t) => { let stub = MachineError::functor_stub(clause_name!("(rdiv)"), 2); @@ -2002,7 +2002,7 @@ impl MachineState { } fn try_functor_compound_case(&mut self, name: ClauseName, arity: usize, - spec: Option<(usize, Specifier)>) + spec: Option) { let name = Addr::Con(Constant::Atom(name, spec)); let arity = Addr::Con(integer!(arity)); @@ -2164,9 +2164,10 @@ impl MachineState { HeapCellValue::NamedStr(2, ref name, Some(_)) if *name == clause_name!("-") => Ok(Addr::HeapCell(s+1)), - _ => Err(self.error_form(MachineError::type_error(ValidType::Pair, - self.heap[s].as_addr(s)), - stub)) + _ => + Err(self.error_form(MachineError::type_error(ValidType::Pair, + self.heap[s].as_addr(s)), + stub)) }, a => Err(self.error_form(MachineError::type_error(ValidType::Pair, a), stub)) } @@ -2389,7 +2390,7 @@ impl MachineState { self.p = CodePtr::Local(self.cp); } }, - &ClauseType::Named(ref name, _, ref idx) | &ClauseType::Op(OpDecl(.., ref name), ref idx) => + &ClauseType::Named(ref name, _, ref idx) | &ClauseType::Op(ref name, _, ref idx) => try_or_fail!(self, call_policy.context_call(self, name.clone(), arity, idx.clone(), indices)), &ClauseType::System(ref ct) => diff --git a/src/prolog/machine/mod.rs b/src/prolog/machine/mod.rs index f3d690cf..cc9d6f67 100644 --- a/src/prolog/machine/mod.rs +++ b/src/prolog/machine/mod.rs @@ -274,13 +274,7 @@ impl Machine { #[inline] pub fn add_batched_ops(&mut self, op_dir: OpDir) { - for ((name, fixity), info) in op_dir { - if info.1 == 0 { - self.indices.op_dir.remove(&(name, fixity)); - } else { - self.indices.op_dir.insert((name, fixity), info); - } - } + self.indices.op_dir.extend(op_dir.into_iter()); } #[inline] diff --git a/src/prolog/machine/modules.rs b/src/prolog/machine/modules.rs index 001bbbf1..7a785434 100644 --- a/src/prolog/machine/modules.rs +++ b/src/prolog/machine/modules.rs @@ -71,6 +71,11 @@ pub trait SubModuleUser fn insert_dir_entry(&mut self, ClauseName, usize, CodeIndex); + fn get_op_module_name(&mut self, name: ClauseName, fixity: Fixity) -> Option + { + self.op_dir().get(&(name, fixity)).map(|op_val| op_val.owning_module()) + } + fn remove_module(&mut self, mod_name: ClauseName, module: &Module) { for (name, arity) in module.module_decl.exports.iter().cloned() { @@ -86,21 +91,21 @@ pub trait SubModuleUser // remove or respecify ops. if arity == 2 { - if let Some((_, _, mod_name)) = self.op_dir().get(&(name.clone(), Fixity::In)).cloned() + if let Some(mod_name) = self.get_op_module_name(name.clone(), Fixity::In) { if mod_name == module.module_decl.name { self.op_dir().remove(&(name.clone(), Fixity::In)); } } } else if arity == 1 { - if let Some((_, _, mod_name)) = self.op_dir().get(&(name.clone(), Fixity::Pre)).cloned() + if let Some(mod_name) = self.get_op_module_name(name.clone(), Fixity::Pre) { if mod_name == module.module_decl.name { self.op_dir().remove(&(name.clone(), Fixity::Pre)); } } - if let Some((_, _, mod_name)) = self.op_dir().get(&(name.clone(), Fixity::Post)).cloned() + if let Some(mod_name) = self.get_op_module_name(name.clone(), Fixity::Post) { if mod_name == module.module_decl.name { self.op_dir().remove(&(name.clone(), Fixity::Post)); diff --git a/src/prolog/machine/system_calls.rs b/src/prolog/machine/system_calls.rs index 7821de66..a05b607b 100644 --- a/src/prolog/machine/system_calls.rs +++ b/src/prolog/machine/system_calls.rs @@ -570,8 +570,8 @@ impl MachineState { } }, &SystemClauseType::OpDeclaration => { - let priority = self[temp_v!(1)].clone(); - let specifier = self[temp_v!(2)].clone(); + let priority = self[temp_v!(1)].clone(); + let specifier = self[temp_v!(2)].clone(); let op = self[temp_v!(3)].clone(); let priority = match self.store(self.deref(priority)) { @@ -599,8 +599,8 @@ impl MachineState { if op_decl.0 == 0 { Ok(op_decl.remove(&mut indices.op_dir)) } else { - let desc = get_desc(op_decl.name(), composite_op!(&indices.op_dir)); - op_decl.submit(module, desc, &mut indices.op_dir) + let spec = get_desc(op_decl.name(), composite_op!(&indices.op_dir)); + op_decl.submit(module, spec, &mut indices.op_dir) } }); diff --git a/src/prolog/machine/toplevel.rs b/src/prolog/machine/toplevel.rs index 4c437a41..0b2ba52e 100644 --- a/src/prolog/machine/toplevel.rs +++ b/src/prolog/machine/toplevel.rs @@ -58,16 +58,16 @@ impl<'a, 'b> CompositeIndices<'a, 'b> } } - fn get_clause_type(&mut self, name: ClauseName, arity: usize, spec: Option<(usize, Specifier)>) -> ClauseType + fn get_clause_type(&mut self, name: ClauseName, arity: usize, spec: Option) -> ClauseType { match ClauseType::from(name, arity, spec) { ClauseType::Named(name, arity, _) => { let idx = self.get_code_index(name.clone(), arity); ClauseType::Named(name, arity, idx.clone()) }, - ClauseType::Op(op_decl, _) => { - let idx = self.get_code_index(op_decl.2.clone(), arity); - ClauseType::Op(op_decl, idx.clone()) + ClauseType::Op(name, spec, _) => { + let idx = self.get_code_index(name.clone(), arity); + ClauseType::Op(name, spec, idx.clone()) }, ct => ct } @@ -741,8 +741,8 @@ impl RelationWorker { self.dynamic_clauses.extend(other.dynamic_clauses.into_iter()); } - fn expand_queue_contents<'a, R>(&mut self, term_stream: &mut TermStream<'a, R>, op_dir: &OpDir) - -> Result<(), SessionError> + fn expand_queue_contents(&mut self, term_stream: &mut TermStream, op_dir: &OpDir) + -> Result<(), SessionError> where R: Read { let mut machine_st = MachineState::new(); @@ -762,8 +762,8 @@ impl RelationWorker { } } -fn term_to_toplevel<'a, R>(term_stream: &mut TermStream<'a, R>, code_dir: &mut CodeDir, term: Term) - -> Result<(TopLevel, RelationWorker), ParserError> +fn term_to_toplevel(term_stream: &mut TermStream, code_dir: &mut CodeDir, term: Term) + -> Result<(TopLevel, RelationWorker), ParserError> where R: Read { let mut rel_worker = RelationWorker::new(); diff --git a/src/prolog/write.rs b/src/prolog/write.rs index f413e1e3..fae1f63b 100644 --- a/src/prolog/write.rs +++ b/src/prolog/write.rs @@ -135,7 +135,7 @@ impl fmt::Display for ClauseType { &ClauseType::System(SystemClauseType::SetCutPoint(r)) => write!(f, "$set_cp({})", r), &ClauseType::Named(ref name, _, ref idx) - | &ClauseType::Op(OpDecl(.., ref name), ref idx) => + | &ClauseType::Op(ref name, _, ref idx) => { let idx = idx.0.borrow(); write!(f, "{}:{}/{}", idx.1, name, idx.0) @@ -150,9 +150,9 @@ impl fmt::Display for HeapCellValue { match self { &HeapCellValue::Addr(ref addr) => write!(f, "{}", addr), - &HeapCellValue::NamedStr(arity, ref name, Some((priority, spec))) => + &HeapCellValue::NamedStr(arity, ref name, Some(ref cell)) => write!(f, "{}/{} (op, priority: {}, spec: {})", name.as_str(), arity, - priority, spec), + cell.prec(), cell.assoc()), &HeapCellValue::NamedStr(arity, ref name, None) => write!(f, "{}/{}", name.as_str(), arity) } -- 2.54.0