rishi/scryer-prolog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

further improvements to cyclic partial list printing (#2635)

Browse Source
This commit is contained in:
Mark Thom
2025-08-23 11:51:56 -07:00
parent b14bda310f
commit ad29f0f180
13 changed files with 84 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/functor_macro.rs
View File

@@ -30,7 +30,7 @@ macro_rules! count {
* in round parentheses for rustc to parse them. See the tests module
* below for examples, especially those involving atom!
* subexpressions.
*/
*/
macro_rules! functor {
($name:expr) => ({

24
src/heap_iter.rs
View File

@@ -28,7 +28,7 @@ pub fn eager_stackful_preorder_iter(
* cyclic terms for the sake of skipping them at the second visit but
* leaves them marked until it is dropped. This makes for, e.g., more
* efficient ground/1 and term_variables/2 definitions.
*/
*/
pub struct EagerStackfulPreOrderHeapIter<'a> {
start_value: HeapCellValue,
@@ -175,7 +175,7 @@ impl IterStackLoc {
}
#[inline]
fn mark_loc(h: usize, heap_or_stack: HeapOrStackTag) -> Self {
pub fn marked_loc(h: usize, heap_or_stack: HeapOrStackTag) -> Self {
IterStackLoc::new()
.with_tag(IterStackLocTag::Marked)
.with_heap_or_stack(heap_or_stack)
@@ -183,7 +183,7 @@ impl IterStackLoc {
}
#[inline]
fn pending_mark_loc(h: usize, heap_or_stack: HeapOrStackTag) -> Self {
fn pending_marked_loc(h: usize, heap_or_stack: HeapOrStackTag) -> Self {
IterStackLoc::new()
.with_tag(IterStackLocTag::PendingMark)
.with_heap_or_stack(heap_or_stack)
@@ -386,7 +386,7 @@ impl<'a, ElideLists: ListElisionPolicy> StackfulPreOrderHeapIter<'a, ElideLists>
while let Some(h) = self.stack.pop() {
if h.is_pending_mark() {
self.push_if_unmarked(h);
self.stack.push(IterStackLoc::mark_loc(
self.stack.push(IterStackLoc::marked_loc(
h.value() as usize,
h.heap_or_stack(),
));
@@ -414,7 +414,7 @@ impl<'a, ElideLists: ListElisionPolicy> StackfulPreOrderHeapIter<'a, ElideLists>
let loc = IterStackLoc::iterable_loc(vh, HeapOrStackTag::Heap);
self.push_if_unmarked(loc);
self.stack.push(IterStackLoc::mark_loc(vh, HeapOrStackTag::Heap));
self.stack.push(IterStackLoc::marked_loc(vh, HeapOrStackTag::Heap));
}
(HeapCellValueTag::Lis, vh) => {
let loc = IterStackLoc::iterable_loc(vh, HeapOrStackTag::Heap);
@@ -428,8 +428,8 @@ impl<'a, ElideLists: ListElisionPolicy> StackfulPreOrderHeapIter<'a, ElideLists>
self.push_if_unmarked(loc);
self.stack.push(IterStackLoc::pending_mark_loc(vh + 1, HeapOrStackTag::Heap));
self.stack.push(IterStackLoc::mark_loc(vh, HeapOrStackTag::Heap));
self.stack.push(IterStackLoc::pending_marked_loc(vh + 1, HeapOrStackTag::Heap));
self.stack.push(IterStackLoc::marked_loc(vh, HeapOrStackTag::Heap));
return Some(self.read_cell(h));
}
@@ -438,14 +438,14 @@ impl<'a, ElideLists: ListElisionPolicy> StackfulPreOrderHeapIter<'a, ElideLists>
self.forward_if_referent_marked(loc);
self.push_if_unmarked(loc);
self.stack.push(IterStackLoc::mark_loc(vh, HeapOrStackTag::Heap));
self.stack.push(IterStackLoc::marked_loc(vh, HeapOrStackTag::Heap));
}
(HeapCellValueTag::StackVar, vs) => {
let loc = IterStackLoc::iterable_loc(vs, HeapOrStackTag::Stack);
self.forward_if_referent_marked(loc);
self.push_if_unmarked(loc);
self.stack.push(IterStackLoc::mark_loc(vs, HeapOrStackTag::Stack));
self.stack.push(IterStackLoc::marked_loc(vs, HeapOrStackTag::Stack));
}
(HeapCellValueTag::PStrLoc, vh) => {
let cell = *cell;
@@ -461,7 +461,7 @@ impl<'a, ElideLists: ListElisionPolicy> StackfulPreOrderHeapIter<'a, ElideLists>
}
self.stack.push(IterStackLoc::iterable_loc(tail_idx - 1, HeapOrStackTag::Heap));
self.stack.push(IterStackLoc::pending_mark_loc(tail_idx, HeapOrStackTag::Heap));
self.stack.push(IterStackLoc::pending_marked_loc(tail_idx, HeapOrStackTag::Heap));
return Some(cell);
}
@@ -469,14 +469,14 @@ impl<'a, ElideLists: ListElisionPolicy> StackfulPreOrderHeapIter<'a, ElideLists>
let l = h.value() as usize;
for l in (l + 2 .. l + arity + 1).rev() {
self.stack.push(IterStackLoc::pending_mark_loc(l, HeapOrStackTag::Heap));
self.stack.push(IterStackLoc::pending_marked_loc(l, HeapOrStackTag::Heap));
}
if arity > 0 {
let first_arg_loc = IterStackLoc::iterable_loc(l+1, HeapOrStackTag::Heap);
self.push_if_unmarked(first_arg_loc);
self.stack.push(IterStackLoc::mark_loc(l+1, HeapOrStackTag::Heap));
self.stack.push(IterStackLoc::marked_loc(l+1, HeapOrStackTag::Heap));
self.forward_if_referent_marked(first_arg_loc);
}

94
src/heap_print.rs
View File

@@ -849,10 +849,8 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
if let Some(mut orig_cell) = self.iter.next() {
loop {
let is_cyclic = orig_cell.get_forwarding_bit();
let cell =
heap_bound_store(self.iter.heap, heap_bound_deref(self.iter.heap, orig_cell));
let cell = unmark_cell_bits!(cell);
let derefed_cell = heap_bound_deref(self.iter.heap, orig_cell);
let cell = unmark_cell_bits!(heap_bound_store(self.iter.heap, derefed_cell));
match self.var_names.get(&cell).cloned() {
Some(var) if cell.is_var() => {
@@ -860,8 +858,6 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
// a name via heap_locs, append the name to
// the current output, and return None. None
// short-circuits handle_heap_term.
// self.iter.pop_stack();
let var_str = var.borrow().to_string();
push_space_if_amb!(self, &var_str, {
@@ -872,8 +868,7 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
}
var_opt => {
if is_cyclic && cell.is_compound(self.iter.heap) {
// self-referential variables are marked "cyclic".
// self-referential variables are marked "cyclic"
match var_opt {
Some(var) => {
// If the term is bound to a named variable,
@@ -889,34 +884,61 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
// otherwise, contract it to an ellipsis.
self.state_stack.push(TokenOrRedirect::Atom(atom!("...")));
} else {
debug_assert!(cell.is_ref());
let h = match cell.get_tag() {
HeapCellValueTag::Lis | HeapCellValueTag::PStrLoc => {
let h = read_heap_cell!(derefed_cell,
(HeapCellValueTag::AttrVar | HeapCellValueTag::Var, h) => {
self.iter.heap[h].set_forwarding_bit(false);
h
}
(HeapCellValueTag::Lis | HeapCellValueTag::PStrLoc) => {
self.iter.focus().value() as usize
}
_ => cell.get_value() as usize,
};
match cell.get_tag() {
HeapCellValueTag::Lis => {
self.state_stack
.push(TokenOrRedirect::Atom(atom!("...")));
return None;
_ => {
cell.get_value() as usize
}
HeapCellValueTag::PStrLoc => {
*max_depth -= 1;
);
let h = IterStackLoc::marked_loc(h, HeapOrStackTag::Heap);
self.iter.push_stack(h);
if let Some(next_cell) = self.iter.next() {
if next_cell.get_forwarding_bit() {
debug_assert_eq!(
cell.get_value(),
next_cell.get_value()
);
/*
* next_cell is forwarded here only if, for lists,
* X = [X|T]. in this case, self.iter has *not*
* pushed X's arguments to its stack, but T is
* at its top from the previous expansion of X.
*
* in this case, expand the iter stack rep to X =
* [[X|T]|T] and continue, terminating recursion
* when max_depth == 0.
*
* similar logic here for PStrLoc, which can only
* recurse from its tail.
*/
read_heap_cell!(next_cell,
(HeapCellValueTag::Lis, l) => {
let tail_h = IterStackLoc::marked_loc(l+1, HeapOrStackTag::Heap);
self.iter.push_stack(tail_h);
self.iter.push_stack(h);
return Some(unmark_cell_bits!(next_cell));
}
(HeapCellValueTag::PStrLoc) => {
self.iter.push_stack(h);
return Some(unmark_cell_bits!(next_cell));
}
_ => {}
);
}
_ => {}
}
self.iter.push_stack(IterStackLoc::iterable_loc(
h,
HeapOrStackTag::Heap,
));
if let Some(cell) = self.iter.next() {
orig_cell = cell;
orig_cell = next_cell;
continue;
}
@@ -933,7 +955,7 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
}
}
} else {
while self.iter.pop_stack().is_none() {}
while self.iter.pop_stack().is_some() {}
None
}
}
@@ -1414,7 +1436,7 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
.push(TokenOrRedirect::FunctorRedirect(max_depth));
self.state_stack.push(TokenOrRedirect::HeadTailSeparator); // bar
self.state_stack
.push(TokenOrRedirect::FunctorRedirect(max_depth + 1));
.push(TokenOrRedirect::FunctorRedirect(max_depth));
self.open_list(switch);
}
@@ -1603,15 +1625,19 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
self.state_stack.push(TokenOrRedirect::Char(c));
} else {
self.iter.pop_stack();
self.state_stack.push(TokenOrRedirect::Atom(atom!("...")));
self.state_stack.push(TokenOrRedirect::HeadTailSeparator);
}
} else if self.max_depth_exhausted(max_depth) {
self.iter.pop_stack();
self.state_stack.push(TokenOrRedirect::Atom(atom!("...")));
self.state_stack.push(TokenOrRedirect::HeadTailSeparator);
} else {
self.state_stack
.push(TokenOrRedirect::FunctorRedirect(max_depth + 1));
.push(TokenOrRedirect::FunctorRedirect(max_depth));
self.state_stack.push(TokenOrRedirect::HeadTailSeparator);
}
}

2
src/machine/code_walker.rs
View File

@@ -41,7 +41,7 @@ fn capture_offset(line: &Instruction, index: usize, stack: &mut Vec<usize>) -> b
/* This function walks the code of a single predicate, supposed to
* begin in code at the offset p. Each instruction is passed to the
* walker function.
*/
*/
pub(crate) fn walk_code(code: &Code, p: usize, mut walker: impl FnMut(&Instruction)) {
let mut stack = vec![p];
let mut visited_indices = IndexSet::with_hasher(FxBuildHasher::default());

2
src/machine/cycle_detection.rs
View File

@@ -19,7 +19,7 @@ use crate::types::*;
* Commonalities with the GC marking algorithm:
* - The contents of forwarded cells are modified only when they are unforwarded
* - Marked (but unforwarded!) cells immediately shift to the backward phase
*/
*/
#[derive(Debug)]
pub(crate) struct CycleDetectingIter<'a, const STOP_AT_CYCLES: bool> {

2
src/machine/disjuncts.rs
View File

@@ -18,7 +18,7 @@ use std::collections::VecDeque;
use std::hash::{Hash, Hasher};
use std::ops::{Deref, DerefMut};
#[derive(Debug, Clone)] //, PartialOrd, PartialEq, Eq, Hash)]
#[derive(Debug, Clone)]//, PartialOrd, PartialEq, Eq, Hash)]
pub struct BranchNumber {
branch_num: Rational,
delta: Rational,

4
src/machine/loader.rs
View File

@@ -46,7 +46,7 @@ use std::rc::Rc;
* loader fail later, all changes must be rolled back, restoring the
* WAM to its prior state. Retraction records describe individual changes
* made by the loader, and they may be used later.
*/
*/
#[derive(Debug)]
pub(crate) enum RetractionRecord {
@@ -108,7 +108,7 @@ pub(crate) enum RetractionRecord {
* "extent" of a code vector is its length prior to an attempted
* module load. The only code vector of the WAM's IndexStore, "code",
* is shared by all modules, including the default "user" module.
*/
*/
pub(super) struct RetractionInfo {
orig_code_extent: usize,

2
src/machine/machine_indices.rs
View File

@@ -136,7 +136,7 @@ impl IndexPtr {
}
}
#[derive(Debug, Clone, Copy)] // , Ord, Hash, PartialOrd, Eq, PartialEq)]
#[derive(Debug, Clone, Copy)]// , Ord, Hash, PartialOrd, Eq, PartialEq)]
pub struct CodeIndex(CodeIndexOffset);
#[cfg(target_pointer_width = "32")]

2
src/machine/preprocessor.rs
View File

@@ -246,7 +246,7 @@ fn setup_qualified_import(mut terms: Vec<Term>) -> Result<UseModuleExport, Compi
* + (mode declarations under the mode syntax, which currently have no effect)
* -
* ?
*/
*/
fn setup_meta_predicate<'a, LS: LoadState<'a>>(
mut terms: Vec<Term>,

2
src/macros.rs
View File

@@ -1,6 +1,6 @@
/* A simple macro to count the arguments in a variadic list
* of token trees.
*/
*/
macro_rules! char_as_cell {
($c: expr) => {

2
src/parser/char_reader.rs
View File

@@ -8,7 +8,7 @@
* wrapping it a Bytes struct.
*
* Unlike BufReader, its buffer is peekable as a char.
*/
*/
use smallvec::*;

2
src/types.rs
View File

@@ -197,7 +197,7 @@ pub enum TrailRef {
BlackboardOffset(Atom, HeapCellValue), // key atom, key value
}
#[allow(clippy::enum_variant_names)] // allow the common "Trailed" prefix
#[allow(clippy::enum_variant_names)]// allow the common "Trailed" prefix
#[derive(BitfieldSpecifier, Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[bits = 6]
pub(crate) enum TrailEntryTag {