From 9b35a316c9a01e7897490b58c222093959a21de4 Mon Sep 17 00:00:00 2001 From: Mark Thom Date: Sun, 12 Mar 2023 14:14:29 -0600 Subject: [PATCH] correct call_residue_vars/3 using new copy_term_3 (#1239) --- build/instructions_template.rs | 4 ++++ src/lib/atts.pl | 4 +++- src/machine/dispatch.rs | 12 ++++++++++-- src/machine/system_calls.rs | 28 ++++++++++++++++++++-------- src/types.rs | 5 +++++ 5 files changed, 42 insertions(+), 11 deletions(-) diff --git a/build/instructions_template.rs b/build/instructions_template.rs index d2cee3bb..937e1c15 100644 --- a/build/instructions_template.rs +++ b/build/instructions_template.rs @@ -574,6 +574,8 @@ enum SystemClauseType { DeleteFromAttributedVarList, #[strum_discriminants(strum(props(Arity = "1", Name = "$delete_all_attributes_from_var")))] DeleteAllAttributesFromVar, + #[strum_discriminants(strum(props(Arity = "2", Name = "$term_attributed_variables_without_attrs")))] + TermAttributedVariablesWithoutAttrs, REPL(REPLCodePtr), } @@ -1636,6 +1638,7 @@ fn generate_instruction_preface() -> TokenStream { &Instruction::CallPutToAttributedVarList(_) | &Instruction::CallDeleteFromAttributedVarList(_) | &Instruction::CallDeleteAllAttributesFromVar(_) | + &Instruction::CallTermAttributedVariablesWithoutAttrs(_) | &Instruction::CallFetchGlobalVar(_) | &Instruction::CallFirstStream(_) | &Instruction::CallFlushOutput(_) | @@ -1855,6 +1858,7 @@ fn generate_instruction_preface() -> TokenStream { &Instruction::ExecutePutToAttributedVarList(_) | &Instruction::ExecuteDeleteFromAttributedVarList(_) | &Instruction::ExecuteDeleteAllAttributesFromVar(_) | + &Instruction::ExecuteTermAttributedVariablesWithoutAttrs(_) | &Instruction::ExecuteFetchGlobalVar(_) | &Instruction::ExecuteFirstStream(_) | &Instruction::ExecuteFlushOutput(_) | diff --git a/src/lib/atts.pl b/src/lib/atts.pl index d6ee47a3..a5cd9582 100644 --- a/src/lib/atts.pl +++ b/src/lib/atts.pl @@ -115,7 +115,9 @@ user:goal_expansion(Term, M:get_atts(Var, Attr)) :- call_residue_vars(Goal, Vars) :- '$get_attr_var_queue_delim'(B), call(Goal), - '$get_attr_var_queue_beyond'(B, Vars). + '$get_attr_var_queue_beyond'(B, AttrVars), + '$project_atts':copy_term(AttrVars, AttrVars, Gs), + '$term_attributed_variables_without_attrs'(Gs, Vars). term_attributed_variables(Term, Vars) :- '$term_attributed_variables'(Term, Vars). diff --git a/src/machine/dispatch.rs b/src/machine/dispatch.rs index e2e144c5..b24cbf76 100644 --- a/src/machine/dispatch.rs +++ b/src/machine/dispatch.rs @@ -4392,11 +4392,11 @@ impl Machine { step_or_fail!(self, self.machine_st.p = self.machine_st.cp); } &Instruction::CallTermVariables(_) => { - self.term_variables(); + self.term_variables(|value| value.is_var()); step_or_fail!(self, self.machine_st.p += 1); } &Instruction::ExecuteTermVariables(_) => { - self.term_variables(); + self.term_variables(|value| value.is_var()); step_or_fail!(self, self.machine_st.p = self.machine_st.cp); } &Instruction::CallTermVariablesUnderMaxDepth(_) => { @@ -5239,6 +5239,14 @@ impl Machine { self.delete_all_attributes_from_var(); self.machine_st.p = self.machine_st.cp; } + &Instruction::CallTermAttributedVariablesWithoutAttrs(_) => { + self.term_variables(|value| value.is_attr_var()); + step_or_fail!(self, self.machine_st.p += 1); + } + &Instruction::ExecuteTermAttributedVariablesWithoutAttrs(_) => { + self.term_variables(|value| value.is_attr_var()); + step_or_fail!(self, self.machine_st.p = self.machine_st.cp); + } } } diff --git a/src/machine/system_calls.rs b/src/machine/system_calls.rs index 39311276..9cd28d1e 100644 --- a/src/machine/system_calls.rs +++ b/src/machine/system_calls.rs @@ -508,23 +508,24 @@ impl MachineState { } #[inline] - pub(crate) fn variable_set( + pub(crate) fn filter_cell_set( &mut self, seen_set: &mut IndexSet, value: HeapCellValue, + filter_fn: impl Fn(HeapCellValue) -> bool, ) { let mut iter = stackful_preorder_iter(&mut self.heap, value); while let Some(value) = iter.next() { let value = unmark_cell_bits!(value); - if value.is_var() { + if filter_fn(value) { let value = unmark_cell_bits!(heap_bound_store( iter.heap, heap_bound_deref(iter.heap, value) )); - if value.is_var() { + if filter_fn(value) { seen_set.insert(value); } } @@ -1243,7 +1244,11 @@ impl Machine { // complete_partial_goal prior to goal_expansion. let mut supp_vars = IndexSet::with_hasher(FxBuildHasher::default()); - self.machine_st.variable_set(&mut supp_vars, self.machine_st.registers[2]); + self.machine_st.filter_cell_set( + &mut supp_vars, + self.machine_st.registers[2], + |value| value.is_var(), + ); struct GoalAnalysisResult { is_simple_goal: bool, @@ -1263,7 +1268,11 @@ impl Machine { // fill expanded_vars with variables of the partial // goal pre-completion by complete_partial_goal. for idx in s + 1 .. s + arity - supp_vars.len() + 1 { - self.machine_st.variable_set(&mut expanded_vars, self.machine_st.heap[idx]); + self.machine_st.filter_cell_set( + &mut expanded_vars, + self.machine_st.heap[idx], + |value| value.is_var(), + ); } let is_simple_goal = if arity >= supp_vars.len() { @@ -4637,7 +4646,9 @@ impl Machine { if self.machine_st.heap[match_site + 1].get_tag() == HeapCellValueTag::Lis { let prev_tail_value = self.machine_st.heap[match_site + 1].get_value(); + self.machine_st.heap[prev_tail].set_value(prev_tail_value); + self.machine_st.attr_var_init.attr_var_queue.push(attr_var_list - 1); } else { self.machine_st.heap[prev_tail] = heap_loc_as_cell!(prev_tail); } @@ -4685,6 +4696,8 @@ impl Machine { self.machine_st.heap.push(str_loc_as_cell!(h+1)); self.machine_st.heap.extend(functor!(atom!(":"), [cell(module), cell(attr)])); + self.machine_st.attr_var_init.attr_var_queue.push(attr_var_list - 1); + match self.match_attribute(self.machine_st.heap[attr_var_list], module, attr) { Some(AttrListMatch { match_site, .. }) => { let (match_site, l) = match match_site { @@ -4714,7 +4727,6 @@ impl Machine { self.machine_st.heap.push(heap_loc_as_cell!(h)); self.machine_st.heap.push(heap_loc_as_cell!(h+5)); - self.machine_st.attr_var_init.attr_var_queue.push(attr_var_list - 1); self.machine_st.trail(TrailRef::AttrVarListLink(attr_var_list, attr_var_list)); } } @@ -6124,7 +6136,7 @@ impl Machine { } #[inline(always)] - pub(crate) fn term_variables(&mut self) { + pub(crate) fn term_variables(&mut self, filter_fn: impl Fn(HeapCellValue) -> bool) { let stored_v = self.deref_register(1); let a2 = self.deref_register(2); @@ -6135,7 +6147,7 @@ impl Machine { let mut seen_set = IndexSet::with_hasher(FxBuildHasher::default()); - self.machine_st.variable_set(&mut seen_set, stored_v); + self.machine_st.filter_cell_set(&mut seen_set, stored_v, filter_fn); let outcome = heap_loc_as_cell!( iter_to_heap_list(&mut self.machine_st.heap, seen_set.into_iter()) diff --git a/src/types.rs b/src/types.rs index a8b66b35..24015fe8 100644 --- a/src/types.rs +++ b/src/types.rs @@ -469,6 +469,11 @@ impl HeapCellValue { ) } + #[inline] + pub fn is_attr_var(self) -> bool { + self.get_tag() == HeapCellValueTag::AttrVar + } + #[inline] pub(crate) fn as_var(self) -> Option { read_heap_cell!(self, -- 2.54.0