Merge branch 'master' of https://github.com/mthom/rusty-wam

Cargo.toml

@@ -27,7 +27,7 @@ libc = "0.2.62"
 nix = "0.15.0"
 num-rug-adapter = { optional = true, version = "0.1.3" }
 ordered-float = "0.5.0"
-prolog_parser = { version = "0.8.53", default-features = false }
+prolog_parser = { version = "0.8.54", default-features = false }
 ref_thread_local = "0.0.0"
 rug = { version = "1.4.0", optional = true }
 rustyline = "6.0.0"

README.md

@@ -239,6 +239,40 @@ only the standard predicate `(=)/2` is used.
 Definite clause grammars as provided by `library(dcgs)` are ideally
 suited for reasoning about strings.
 
+### Tabling (SLG resolution)
+
+One of the foremost attractions of Prolog is that logical consequences
+of pure programs can be derived by various execution strategies
+that differ regarding essential properties such as termination,
+completeness and efficiency.
+
+The default execution strategy of Prolog is depth-first search with
+chronological backtracking. This strategy is very efficient. Its main
+drawback is that it is *incomplete*: It may fail to find any solution
+even if one exists.
+
+Scryer Prolog supports an alternative execution strategy which is
+called *tabling* and also known as tabled execution and
+SLG resolution. To enable tabled execution for a predicate, use
+[`library(tabling)`](src/prolog/lib/tabling.pl) and add a `(table)/1`
+directive for the desired predicate indicator. For example, if we
+write:
+
+```
+:- use_module(library(tabling)).
+:- table a/0.
+
+a :- a.
+```
+
+Then the query `?- a.` *terminates* (and fails), whereas it
+does not terminate with the default execution strategy.
+
+Scryer Prolog implements tabling via *delimited continuations* as
+described in [*Tabling as a Library with Delimited
+Control*](https://biblio.ugent.be/publication/6880648/file/6885145.pdf)
+by Desouter et. al.
+
 ### Modules
 
 Scryer has a simple predicate-based module system. It provides a
@@ -307,6 +341,14 @@ The modules that ship with Scryer Prolog are also called
 * [`time`](src/prolog/lib/time.pl)
   `time/1` reports the CPU time of a goal. It is useful
   for measuring the performance of your code.
+* [`cont`](src/prolog/lib/cont.pl)
+  Provides *delimited continuations* via `reset/3` and `shift/1`.
+
+To read contents of external files, use `phrase_from_file/2` from
+[`library(pio)`](src/prolog/lib/pio.pl) to apply a DCG to
+file contents. The predicates in
+[`library(charsio)`](src/prolog/lib/charsio.pl) are also useful for
+parsing.
 
 To use predicates provided by the `lists` library, write:
 
@@ -343,7 +385,6 @@ REPL:
 
 ```
 ?- [user].
-(type Enter + Ctrl-D to terminate the stream when finished)
 :- module(test, [local_member/2]).
 :- use_module(library(lists)).
 

src/prolog/arithmetic.rs

@@ -23,6 +23,7 @@ use std::ops::{Add, Div, Mul, Neg, Sub};
 use std::rc::Rc;
 use std::vec::Vec;
 
+#[derive(Debug)]
 pub struct ArithInstructionIterator<'a> {
     state_stack: Vec<TermIterState<'a>>,
 }
@@ -68,6 +69,7 @@ impl<'a> ArithInstructionIterator<'a> {
     }
 }
 
+#[derive(Debug)]
 pub enum ArithTermRef<'a> {
     Constant(&'a Constant),
     Op(ClauseName, usize), // name, arity.
@@ -109,6 +111,7 @@ impl<'a> Iterator for ArithInstructionIterator<'a> {
     }
 }
 
+#[derive(Debug)]
 pub struct ArithmeticEvaluator<'a> {
     bindings: &'a AllocVarDict,
     interm: Vec<ArithmeticTerm>,

src/prolog/clause_types.rs

@@ -8,7 +8,7 @@ use ref_thread_local::RefThreadLocal;
 
 use std::collections::BTreeMap;
 
-#[derive(Clone, Copy, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub enum CompareNumberQT {
     GreaterThan,
     LessThan,
@@ -31,7 +31,7 @@ impl CompareNumberQT {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum CompareTermQT {
     LessThan,
     LessThanOrEqual,
@@ -50,7 +50,7 @@ impl CompareTermQT {
     }
 }
 
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ArithmeticTerm {
     Reg(RegType),
     Interm(usize),
@@ -67,7 +67,7 @@ impl ArithmeticTerm {
     }
 }
 
-#[derive(Clone, Eq, PartialEq)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub enum InlinedClauseType {
     CompareNumber(CompareNumberQT, ArithmeticTerm, ArithmeticTerm),
     IsAtom(RegType),
@@ -145,7 +145,7 @@ impl InlinedClauseType {
     }
 }
 
-#[derive(Copy, Clone, Eq, PartialEq)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum SystemClauseType {
     AbolishClause,
     AbolishModuleClause,
@@ -178,6 +178,7 @@ pub enum SystemClauseType {
     ExpandTerm,
     FetchGlobalVar,
     FetchGlobalVarWithOffset,
+    FileToChars,
     GetChar,
     GetSingleChar,
     ResetAttrVarState,
@@ -312,6 +313,7 @@ impl SystemClauseType {
             &SystemClauseType::FetchGlobalVarWithOffset => {
                 clause_name!("$fetch_global_var_with_offset")
             }
+            &SystemClauseType::FileToChars => clause_name!("$file_to_chars"),
             &SystemClauseType::GetChar => clause_name!("$get_char"),
             &SystemClauseType::GetSingleChar => clause_name!("$get_single_char"),
             &SystemClauseType::ResetAttrVarState => clause_name!("$reset_attr_var_state"),
@@ -461,6 +463,7 @@ impl SystemClauseType {
             ("$expand_goal", 2) => Some(SystemClauseType::ExpandGoal),
             ("$fetch_global_var", 2) => Some(SystemClauseType::FetchGlobalVar),
             ("$fetch_global_var_with_offset", 3) => Some(SystemClauseType::FetchGlobalVarWithOffset),
+            ("$file_to_chars", 2) => Some(SystemClauseType::FileToChars),
             ("$get_char", 1) => Some(SystemClauseType::GetChar),
             ("$get_single_char", 1) => Some(SystemClauseType::GetSingleChar),
             ("$points_to_cont_reset_marker", 1) => {
@@ -554,7 +557,7 @@ impl SystemClauseType {
     }
 }
 
-#[derive(Clone, Eq, PartialEq)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub enum BuiltInClauseType {
     AcyclicTerm,
     Arg,
@@ -572,7 +575,7 @@ pub enum BuiltInClauseType {
     Sort,
 }
 
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ClauseType {
     BuiltIn(BuiltInClauseType),
     CallN,

src/prolog/codegen.rs

@@ -17,12 +17,14 @@ use std::cell::Cell;
 use std::rc::Rc;
 use std::vec::Vec;
 
+#[derive(Debug)]
 pub struct CodeGenerator<TermMarker> {
     marker: TermMarker,
     pub var_count: IndexMap<Rc<Var>, usize>,
     non_counted_bt: bool,
 }
 
+#[derive(Debug)]
 pub struct ConjunctInfo<'a> {
     pub perm_vs: VariableFixtures<'a>,
     pub num_of_chunks: usize,

src/prolog/debray_allocator.rs

@@ -12,6 +12,7 @@ use std::cell::Cell;
 use std::collections::BTreeSet;
 use std::rc::Rc;
 
+#[derive(Debug)]
 pub struct DebrayAllocator {
     bindings: IndexMap<Rc<Var>, VarData>,
     arg_c: usize,

src/prolog/fixtures.rs

@@ -13,6 +13,7 @@ use std::rc::Rc;
 use std::vec::Vec;
 
 // labeled with chunk numbers.
+#[derive(Debug)]
 pub enum VarStatus {
     Perm(usize),
     Temp(usize, TempVarData), // Perm(chunk_num) | Temp(chunk_num, _)
@@ -22,6 +23,7 @@ pub type OccurrenceSet = BTreeSet<(GenContext, usize)>;
 
 // Perm: 0 initially, a stack register once processed.
 // Temp: labeled with chunk_num and temp offset (unassigned if 0).
+#[derive(Debug)]
 pub enum VarData {
     Perm(usize),
     Temp(usize, usize, TempVarData),
@@ -36,6 +38,7 @@ impl VarData {
     }
 }
 
+#[derive(Debug)]
 pub struct TempVarData {
     pub last_term_arity: usize,
     pub use_set: OccurrenceSet,
@@ -79,6 +82,7 @@ impl TempVarData {
 
 type VariableFixture<'a> = (VarStatus, Vec<&'a Cell<VarReg>>);
 
+#[derive(Debug)]
 pub struct VariableFixtures<'a>{
     perm_vars: IndexMap<Rc<Var>, VariableFixture<'a>>,
     last_chunk_temp_vars: IndexSet<Rc<Var>>
@@ -248,6 +252,7 @@ impl<'a> VariableFixtures<'a> {
     }
 }
 
+#[derive(Debug)]
 pub struct UnsafeVarMarker {
     pub unsafe_vars: IndexMap<RegType, usize>,
     pub safe_vars: IndexSet<RegType>,

src/prolog/forms.rs

@@ -22,7 +22,7 @@ pub type PredicateKey = (ClauseName, usize); // name, arity.
 // of vars (we get their adjoining cells this way).
 pub type JumpStub = Vec<Term>;
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum TopLevel {
     Declaration(Declaration),
     Fact(Term, usize, usize), // Term, line_num, col_num
@@ -42,7 +42,7 @@ impl TopLevel {
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum Level {
     Deep,
     Root,
@@ -58,7 +58,7 @@ impl Level {
     }
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum QueryTerm {
     // register, clause type, subterms, use default call policy.
     Clause(Cell<RegType>, ClauseType, Vec<Box<Term>>, bool),
@@ -86,13 +86,13 @@ impl QueryTerm {
     }
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct Rule {
     pub head: (ClauseName, Vec<Box<Term>>, QueryTerm),
     pub clauses: Vec<QueryTerm>,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct Predicate(pub Vec<PredicateClause>);
 
 impl Predicate {
@@ -114,7 +114,7 @@ impl Predicate {
     }
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum ListingSource {
     File(ClauseName, PathBuf), // filename, path
     User,
@@ -326,7 +326,7 @@ impl ClauseConsistency for Predicate {
 
 pub type CompiledResult = (Predicate, VecDeque<TopLevel>);
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum PredicateClause {
     Fact(Term, usize, usize), // Term, line number, column number.
     Rule(Rule, usize, usize), // Term, line number, column number.
@@ -371,7 +371,7 @@ impl PredicateClause {
     }
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum ModuleSource {
     Library(ClauseName),
     File(ClauseName),
@@ -392,13 +392,13 @@ impl ModuleSource {
 
 pub type ScopedPredicateKey = (ClauseName, PredicateKey); // module name, predicate indicator.
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum MultiFileIndicator {
     LocalScoped(ClauseName, usize), // name, arity
     ModuleScoped(ScopedPredicateKey),
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum Declaration {
     Dynamic(ClauseName, usize), // name, arity
     EndOfFile,
@@ -433,7 +433,7 @@ impl Declaration {
     }
 }
 
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct OpDecl(pub usize, pub Specifier, pub ClauseName);
 
 impl OpDecl {
@@ -558,18 +558,19 @@ pub fn fetch_op_spec(
 
 pub type ModuleDir = IndexMap<ClauseName, Module>;
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum ModuleExport {
     OpDecl(OpDecl),
     PredicateKey(PredicateKey),
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct ModuleDecl {
     pub name: ClauseName,
     pub exports: Vec<ModuleExport>,
 }
 
+#[derive(Debug)]
 pub struct Module {
     pub atom_tbl: TabledData<Atom>,
     pub module_decl: ModuleDecl,
@@ -587,7 +588,7 @@ pub struct Module {
     pub listing_src: ListingSource,
  }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum Number {
     Float(OrderedFloat<f64>),
     Integer(Rc<Integer>),

src/prolog/heap_iter.rs

@@ -7,6 +7,7 @@ use std::cmp::Ordering;
 use std::ops::Deref;
 use std::vec::Vec;
 
+#[derive(Debug)]
 pub struct HCPreOrderIterator<'a> {
     pub machine_st: &'a MachineState,
     pub state_stack: Vec<Addr>,
@@ -127,6 +128,7 @@ pub trait MutStackHCIterator<'b> where Self: Iterator
     fn stack(&'b mut self) -> Self::MutStack;
 }
 
+#[derive(Debug)]
 pub struct HCPostOrderIterator<'a> {
     base_iter: HCPreOrderIterator<'a>,
     parent_stack: Vec<(usize, Addr)>, // number of children, parent node.
@@ -229,6 +231,7 @@ impl<'b, 'a: 'b> MutStackHCIterator<'b> for HCPreOrderIterator<'a> {
     }
 }
 
+#[derive(Debug)]
 pub struct HCAcyclicIterator<'a> {
     iter: HCPreOrderIterator<'a>,
     seen: IndexSet<Addr>,
@@ -269,6 +272,7 @@ impl<'a> Iterator for HCAcyclicIterator<'a>
     }
 }
 
+#[derive(Debug)]
 pub struct HCZippedAcyclicIterator<'a> {
     i1: HCPreOrderIterator<'a>,
     i2: HCPreOrderIterator<'a>,

src/prolog/heap_print.rs

@@ -18,7 +18,7 @@ use std::ops::{Range, RangeFrom};
 use std::rc::Rc;
 
 /* contains the location, name, precision and Specifier of the parent op. */
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum DirectedOp {
     Left(ClauseName, SharedOpDesc),
     Right(ClauseName, SharedOpDesc),
@@ -162,7 +162,7 @@ fn char_to_string(is_quoted: bool, c: char) -> String {
     }
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 enum TokenOrRedirect {
     Atom(ClauseName),
     BarAsOp,
@@ -197,6 +197,7 @@ pub trait HCValueOutputter {
     fn range_from(&self, range: RangeFrom<usize>) -> &str;
 }
 
+#[derive(Debug)]
 pub struct PrinterOutputter {
     contents: String,
 }
@@ -335,6 +336,7 @@ impl MachineState {
 
 type ReverseHeapVarDict = IndexMap<Addr, Rc<Var>>;
 
+#[derive(Debug)]
 pub struct HCPrinter<'a, Outputter> {
     outputter: Outputter,
     machine_st: &'a MachineState,

src/prolog/instructions.rs

@@ -45,6 +45,7 @@ impl ArithmeticTerm {
     }
 }
 
+#[derive(Debug)]
 pub enum ChoiceInstruction {
     DefaultRetryMeElse(usize),
     DefaultTrustMe,
@@ -75,6 +76,7 @@ impl ChoiceInstruction {
     }
 }
 
+#[derive(Debug)]
 pub enum CutInstruction {
     Cut(RegType),
     GetLevel(RegType),
@@ -104,6 +106,7 @@ impl CutInstruction {
     }
 }
 
+#[derive(Debug)]
 pub enum IndexedChoiceInstruction {
     Retry(usize),
     Trust(usize),
@@ -140,6 +143,7 @@ impl IndexedChoiceInstruction {
     }
 }
 
+#[derive(Debug)]
 pub enum Line {
     Arithmetic(ArithmeticInstruction),
     Choice(ChoiceInstruction),
@@ -175,7 +179,7 @@ impl Line {
     }
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum ArithmeticInstruction {
     Add(ArithmeticTerm, ArithmeticTerm, usize),
     Sub(ArithmeticTerm, ArithmeticTerm, usize),
@@ -374,6 +378,7 @@ impl ArithmeticInstruction {
     }
 }
 
+#[derive(Debug)]
 pub enum ControlInstruction {
     Allocate(usize), // num_frames.
     // name, arity, perm_vars after threshold, last call, use default call policy.
@@ -419,6 +424,7 @@ impl ControlInstruction {
     }
 }
 
+#[derive(Debug)]
 pub enum IndexingInstruction {
     SwitchOnTerm(usize, usize, usize, usize),
     SwitchOnConstant(usize, IndexMap<Constant, usize>),
@@ -459,7 +465,7 @@ impl IndexingInstruction {
     }
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum FactInstruction {
     GetConstant(Level, Constant, RegType),
     GetList(Level, RegType),
@@ -571,7 +577,7 @@ impl FactInstruction {
     }
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum QueryInstruction {
     GetVariable(RegType, usize),
     PutConstant(Level, Constant, RegType),

src/prolog/iterators.rs

@@ -6,11 +6,12 @@ use crate::prolog::machine::machine_indices::*;
 
 use std::cell::Cell;
 use std::collections::VecDeque;
+use std::fmt;
 use std::iter::*;
 use std::rc::Rc;
 use std::vec::Vec;
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum TermRef<'a> {
     AnonVar(Level),
     Cons(Level, &'a Cell<RegType>, &'a Term, &'a Term),
@@ -33,6 +34,7 @@ impl<'a> TermRef<'a> {
     }
 }
 
+#[derive(Debug)]
 pub enum TermIterState<'a> {
     AnonVar(Level),
     Constant(Level, &'a Cell<RegType>, &'a Constant),
@@ -124,6 +126,7 @@ impl<'a> TermIterState<'a> {
     }
 }
 
+#[derive(Debug)]
 pub struct QueryIterator<'a> {
     state_stack: Vec<TermIterState<'a>>,
 }
@@ -294,6 +297,7 @@ impl<'a> Iterator for QueryIterator<'a> {
     }
 }
 
+#[derive(Debug)]
 pub struct FactIterator<'a> {
     state_queue: VecDeque<TermIterState<'a>>,
     iterable_root: bool,
@@ -402,6 +406,7 @@ pub fn breadth_first_iter(term: &Term, iterable_root: bool) -> FactIterator {
     FactIterator::new(term, iterable_root)
 }
 
+#[derive(Debug)]
 pub enum ChunkedTerm<'a> {
     HeadClause(ClauseName, &'a Vec<Box<Term>>),
     BodyTerm(&'a QueryTerm),
@@ -439,6 +444,18 @@ pub struct ChunkedIterator<'a> {
     cut_var_in_head: bool,
 }
 
+impl<'a> fmt::Debug for ChunkedIterator<'a> {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.debug_struct("ChunkedIterator")
+            .field("chunk_num", &self.chunk_num)
+            // Hacky solution.
+            .field("iter", &"Box<dyn Iterator<Item = ChunkedTerm<'a>> + 'a>")
+            .field("deep_cut_encountered", &self.deep_cut_encountered)
+            .field("cut_var_in_head", &self.cut_var_in_head)
+            .finish()
+    }
+}
+
 type ChunkedIteratorItem<'a> = (usize, usize, Vec<ChunkedTerm<'a>>);
 type RuleBodyIteratorItem<'a> = (usize, usize, Vec<&'a QueryTerm>);
 

src/prolog/lib/charsio.pl

@@ -47,7 +47,7 @@ extend_var_list(Value, VarList, NewVarList, VarType) :-
     term_variables(Value, Vars),
     extend_var_list_(Vars, 0, VarList, NewVarList, VarType).
 
-extend_var_list_([], N, VarList, VarList, _).
+extend_var_list_([], _, VarList, VarList, _).
 extend_var_list_([V|Vs], N, VarList, NewVarList, VarType) :-
     (  var_list_contains_variable(VarList, V) ->
        extend_var_list_(Vs, N, VarList, NewVarList, VarType)
@@ -60,36 +60,44 @@ extend_var_list_([V|Vs], N, VarList, NewVarList, VarType) :-
 char_type(Char, Type) :-
     (   var(Char) -> throw(error(instantiation_error, char_type/2))
     ;   atom_length(Char, 1) ->
-        (   ground(Type) -> '$char_type'(Char, Type)
+        (   ground(Type) ->
-        ;   Type = symbolic_control, '$char_type'(Char, Type)
+            (   ctype(Type) ->
-        ;   Type = layout, '$char_type'(Char, Type)
+                '$char_type'(Char, Type)
-        ;   Type = symbolic_hexadecimal, Char = x
+            ;   throw(error(domain_error(char_type, Type), char_type/2))
-        ;   Type = octal_digit, '$char_type'(Char, Type)
+            )
-        ;   Type = binary_digit, '$char_type'(Char, Type)
+        ;   ctype(Type),
-        ;   Type = hexadecimal_digit, '$char_type'(Char, Type)
+            '$char_type'(Char, Type)
-        ;   Type = exponent, '$char_type'(Char, Type)
-        ;   Type = sign, '$char_type'(Char, Type)
-        ;   Type = upper, '$char_type'(Char, Type)
-        ;   Type = lower, '$char_type'(Char, Type)
-        ;   Type = graphic, '$char_type'(Char, Type)
-        ;   Type = alpha, '$char_type'(Char, Type)
-        ;   Type = decimal_digit, '$char_type'(Char, Type)
-        ;   Type = alnum, '$char_type'(Char, Type)
-        ;   Type = meta, '$char_type'(Char, Type)
-        ;   Type = solo, '$char_type'(Char, Type)
-        ;   Type = prolog, '$char_type'(Char, Type)
-        ;   Type = alphabetic, '$char_type'(Char, Type)
-        ;   Type = whitespace, '$char_type'(Char, Type)
-        ;   Type = control, '$char_type'(Char, Type)
-        ;   Type = numeric, '$char_type'(Char, Type)
-        ;   Type = ascii, '$char_type'(Char, Type)
-        ;   Type = ascii_punctuation, '$char_type'(Char, Type)
-        ;   Type = ascii_graphic, '$char_type'(Char, Type)
         )
     ;   throw(error(type_error(in_character, Char), char_type/2))
     ).
 
 
+ctype(alnum).
+ctype(alpha).
+ctype(alphabetic).
+ctype(ascii).
+ctype(ascii_graphic).
+ctype(ascii_punctuation).
+ctype(binary_digit).
+ctype(control).
+ctype(decimal_digit).
+ctype(exponent).
+ctype(graphic).
+ctype(hexadecimal_digit).
+ctype(layout).
+ctype(lower).
+ctype(meta).
+ctype(numeric).
+ctype(octal_digit).
+ctype(prolog).
+ctype(sign).
+ctype(solo).
+ctype(symbolic_control).
+ctype(symbolic_hexadecimal).
+ctype(upper).
+ctype(whitespace).
+
+
 get_single_char(C) :-
     (  var(C) -> '$get_single_char'(C)
     ;  atom_length(C, 1) -> '$get_single_char'(C)

src/prolog/lib/pio.pl

@@ -0,0 +1,11 @@
+:- module(pio, [phrase_from_file/2]).
+
+:- use_module(library(dcgs)).
+
+phrase_from_file(NT, File) :-
+    (   var(File) -> throw(error(instantiation_error, phrase_from_file/2))
+    ;   (\+ atom(File) ; File = []) ->
+            throw(error(domain_error(source_sink, File), phrase_from_file/2))
+    ;   '$file_to_chars'(File, Chars),
+        phrase(NT, Chars)
+    ).

src/prolog/machine/attributed_variables.rs

@@ -8,6 +8,7 @@ pub static PROJECT_ATTRS: &str = include_str!("project_attributes.pl");
 
 pub(super) type Bindings = Vec<(usize, Addr)>;
 
+#[derive(Debug)]
 pub(super) struct AttrVarInitializer {
     pub(super) attribute_goals: Vec<Addr>,
     pub(super) attr_var_queue: Vec<usize>,

src/prolog/machine/code_repo.rs

@@ -12,6 +12,7 @@ use indexmap::IndexSet;
 use std::collections::VecDeque;
 use std::mem;
 
+#[derive(Debug)]
 pub struct CodeRepo {
     pub(super) cached_query: Code,
     pub(super) goal_expanders: Code,

src/prolog/machine/compile.rs

@@ -409,6 +409,7 @@ fn compile_into_module_impl(
     Ok(compiler.drop_expansions(&mut wam.code_repo))
 }
 
+#[derive(Debug)]
 pub struct GatherResult {
     dynamic_clause_map: DynamicClauseMap,
     pub(crate) worker_results: Vec<PredicateCompileQueue>,
@@ -423,6 +424,7 @@ pub struct GatherResult {
     in_situ_module_dir: ModuleStubDir,
 }
 
+#[derive(Debug)]
 pub struct ClauseCodeGenerator {
     len_offset: usize,
     code: Code,
@@ -529,6 +531,7 @@ fn insert_or_refresh_term_dir_quantum(
     }
 }
 
+#[derive(Debug)]
 pub struct ListingCompiler {
     module: Option<Module>,
     user_term_dir: TermDir,

src/prolog/machine/copier.rs

@@ -7,7 +7,7 @@ use std::ops::IndexMut;
 
 type Trail = Vec<(Ref, HeapCellValue)>;
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum AttrVarPolicy {
     DeepCopy,
     StripAttributes
@@ -28,6 +28,7 @@ fn copy_term<T: CopierTarget>(target: T, addr: Addr, attr_var_policy: AttrVarPol
     copy_term_state.copy_term_impl(addr);
 }
 
+#[derive(Debug)]
 struct CopyTermState<T: CopierTarget> {
     trail: Trail,
     scan: usize,

src/prolog/machine/heap.rs

@@ -11,6 +11,7 @@ use std::mem;
 use std::ops::{Index, IndexMut};
 use std::ptr;
 
+#[derive(Debug)]
 pub(crate) struct StandardHeapTraits {}
 
 impl RawBlockTraits for StandardHeapTraits {
@@ -25,6 +26,7 @@ impl RawBlockTraits for StandardHeapTraits {
     }
 }
 
+#[derive(Debug)]
 pub(crate) struct HeapTemplate<T: RawBlockTraits> {
     buf: RawBlock<T>,
     _marker: PhantomData<HeapCellValue>,
@@ -39,6 +41,7 @@ impl<T: RawBlockTraits> Drop for HeapTemplate<T> {
     }
 }
 
+#[derive(Debug)]
 pub(crate)
 struct HeapIntoIter<T: RawBlockTraits> {
     offset: usize,
@@ -72,6 +75,7 @@ impl<T: RawBlockTraits> Iterator for HeapIntoIter<T> {
     }
 }
 
+#[derive(Debug)]
 pub(crate)
 struct HeapIter<'a, T: RawBlockTraits> {
     offset: usize,
@@ -110,6 +114,7 @@ fn print_heap_terms<'a, I: Iterator<Item = &'a HeapCellValue>>(heap: I, h: usize
     }
 }
 
+#[derive(Debug)]
 pub(crate)
 struct HeapIterMut<'a, T: RawBlockTraits> {
     offset: usize,

src/prolog/machine/machine_errors.rs

@@ -10,12 +10,13 @@ use std::rc::Rc;
 
 pub(crate) type MachineStub = Vec<HeapCellValue>;
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 enum ErrorProvenance {
     Constructed, // if constructed, offset the addresses.
     Received,    // otherwise, preserve the addresses.
 }
 
+#[derive(Debug)]
 pub(super) struct MachineError {
     stub: MachineStub,
     location: Option<(usize, usize)>, // line_num, col_num
@@ -447,7 +448,7 @@ impl MachineError {
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum Permission {
     Access,
     Create,
@@ -469,7 +470,7 @@ impl Permission {
 }
 
 // from 7.12.2 b) of 13211-1:1995
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum ValidType {
     Atom,
     Atomic,
@@ -514,7 +515,7 @@ impl ValidType {
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum DomainErrorType {
     NotLessThanZero,
     Order,
@@ -534,7 +535,7 @@ impl DomainErrorType {
 }
 
 // from 7.12.2 f) of 13211-1:1995
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum RepFlag {
     Character,
     CharacterCode,
@@ -558,7 +559,7 @@ impl RepFlag {
 }
 
 // from 7.12.2 g) of 13211-1:1995
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum EvalError {
     FloatOverflow,
     Undefined,
@@ -578,7 +579,7 @@ impl EvalError {
 }
 
 // used by '$skip_max_list'.
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub(super) enum CycleSearchResult {
     EmptyList,
     NotList,
@@ -722,6 +723,7 @@ impl MachineState {
     }
 }
 
+#[derive(Debug)]
 pub enum ExistenceError {
     Module(ClauseName),
     Procedure(ClauseName, usize),
@@ -729,6 +731,7 @@ pub enum ExistenceError {
     Stream(Addr),
 }
 
+#[derive(Debug)]
 pub enum SessionError {
     CannotOverwriteBuiltIn(ClauseName),
     CannotOverwriteImport(ClauseName),
@@ -741,6 +744,7 @@ pub enum SessionError {
     ParserError(ParserError),
 }
 
+#[derive(Debug)]
 pub enum EvalSession {
     EntrySuccess,
     Error(SessionError),

src/prolog/machine/machine_indices.rs

@@ -21,16 +21,17 @@ use std::cell::RefCell;
 use std::cmp::Ordering;
 use std::collections::{BTreeMap, VecDeque};
 use std::convert::TryFrom;
+use std::fmt;
 use std::mem;
 use std::ops::{Add, AddAssign, Sub, SubAssign};
 use std::rc::Rc;
 
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct OrderedOpDirKey(pub ClauseName, pub Fixity);
 
 pub type OssifiedOpDir = BTreeMap<OrderedOpDirKey, (usize, Specifier)>;
 
-#[derive(Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum DBRef {
     NamedPred(ClauseName, usize, Option<SharedOpDesc>),
     Op(
@@ -43,7 +44,7 @@ pub enum DBRef {
 }
 
 // 7.2
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub enum TermOrderCategory {
     Variable,
     FloatingPoint,
@@ -52,7 +53,7 @@ pub enum TermOrderCategory {
     Compound,
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum Addr {
     AttrVar(usize),
     Char(char),
@@ -71,7 +72,7 @@ pub enum Addr {
     Usize(usize),
 }
 
-#[derive(Clone, Copy, Hash, Eq, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq, PartialOrd)]
 pub enum Ref {
     AttrVar(usize),
     HeapCell(usize),
@@ -361,7 +362,7 @@ impl SubAssign<usize> for Addr {
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum TrailRef {
     Ref(Ref),
     AttrVarHeapLink(usize),
@@ -374,6 +375,7 @@ impl From<Ref> for TrailRef {
     }
 }
 
+#[derive(Debug)]
 pub enum HeapCellValue {
     Addr(Addr),
     Atom(ClauseName, Option<SharedOpDesc>),
@@ -446,7 +448,7 @@ impl From<Addr> for HeapCellValue {
     }
 }
 
-#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
 pub enum IndexPtr {
     DynamicUndefined, // a predicate, declared as dynamic, whose location in code is as yet undefined.
     Undefined,
@@ -456,7 +458,7 @@ pub enum IndexPtr {
     UserTermExpansion
 }
 
-#[derive(Clone, Ord, PartialOrd, Eq, PartialEq)]
+#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
 pub struct CodeIndex(pub Rc<RefCell<(IndexPtr, ClauseName)>>);
 
 impl CodeIndex {
@@ -511,7 +513,7 @@ impl From<(usize, ClauseName)> for CodeIndex {
     }
 }
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum DynamicAssertPlace {
     Back,
     Front,
@@ -535,7 +537,7 @@ impl DynamicAssertPlace {
     }
 }
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum DynamicTransactionType {
     Abolish,
     Assert(DynamicAssertPlace),
@@ -545,7 +547,7 @@ pub enum DynamicTransactionType {
     Retract, // dynamic index of the clause to remove.
 }
 
-#[derive(Clone, Copy, PartialOrd, Ord, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq)]
 pub enum REPLCodePtr {
     CompileBatch,
     UseModule,
@@ -554,7 +556,7 @@ pub enum REPLCodePtr {
     UseQualifiedModuleFromFile
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum CodePtr {
     BuiltInClause(BuiltInClauseType, LocalCodePtr), // local is the successor call.
     CallN(usize, LocalCodePtr, bool),               // arity, local, last call.
@@ -773,7 +775,7 @@ impl AddAssign<usize> for CodePtr {
 pub type HeapVarDict = IndexMap<Rc<Var>, Addr>;
 pub type AllocVarDict = IndexMap<Rc<Var>, VarData>;
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct DynamicPredicateInfo {
     pub(super) clauses_subsection_p: usize, // a LocalCodePtr::DirEntry value.
 }
@@ -793,6 +795,7 @@ pub type DynamicCodeDir = IndexMap<(ClauseName, ClauseName, usize), DynamicPredi
 
 pub type GlobalVarDir = IndexMap<ClauseName, (Ball, Option<usize>)>;
 
+#[derive(Debug)]
 pub(crate) struct ModuleStub {
     pub(crate) atom_tbl: TabledData<Atom>,
     pub(crate) in_situ_code_dir: InSituCodeDir,
@@ -810,6 +813,7 @@ impl ModuleStub {
 pub(crate) type ModuleStubDir = IndexMap<ClauseName, ModuleStub>;
 pub(crate) type StreamAliasDir = IndexMap<ClauseName, Stream>;
 
+#[derive(Debug)]
 pub struct IndexStore {
     pub(super) atom_tbl: TabledData<Atom>,
     pub(super) code_dir: CodeDir,
@@ -960,6 +964,7 @@ impl IndexStore {
 pub type CodeDir = BTreeMap<PredicateKey, CodeIndex>;
 pub type TermDir = IndexMap<PredicateKey, (Predicate, VecDeque<TopLevel>)>;
 
+#[derive(Debug)]
 pub struct TermDirQuantumEntry {
     pub old_terms: (Predicate, VecDeque<TopLevel>),
     pub new_terms: (Predicate, VecDeque<TopLevel>),
@@ -988,6 +993,7 @@ impl TermDirQuantumEntry {
     }
 }
 
+#[derive(Debug)]
 pub struct TermDirQuantum(IndexMap<PredicateKey, TermDirQuantumEntry>);
 
 impl TermDirQuantum {
@@ -1031,7 +1037,7 @@ impl TermDirQuantum {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Ord, PartialOrd)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd)]
 pub enum CompileTimeHook {
     GoalExpansion,
     TermExpansion,
@@ -1085,6 +1091,16 @@ pub enum RefOrOwned<'a, T: 'a> {
     Owned(T),
 }
 
+impl<'a, T: 'a + fmt::Debug> fmt::Debug for RefOrOwned<'a, T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            &RefOrOwned::Borrowed(ref borrowed) =>
+                write!(f, "Borrowed({:?})", borrowed),
+            &RefOrOwned::Owned(ref owned) => write!(f, "Owned({:?})", owned),
+        }
+    }
+}
+
 impl<'a, T> RefOrOwned<'a, T> {
     pub fn as_ref(&'a self) -> &'a T {
         match self {

src/prolog/machine/machine_state.rs

@@ -21,10 +21,12 @@ use indexmap::{IndexMap, IndexSet};
 
 use std::cmp::Ordering;
 use std::convert::TryFrom;
+use std::fmt;
 use std::io::Write;
 use std::mem;
 use std::ops::{Index, IndexMut};
 
+#[derive(Debug)]
 pub(crate) struct HeapPStrIter<'a> {
     focus: Addr,
     machine_st: &'a MachineState,
@@ -74,7 +76,7 @@ impl<'a> HeapPStrIter<'a> {
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub(crate) enum PStrIteratee {
     Char(char),
     PStrSegment(usize, usize),
@@ -306,6 +308,7 @@ fn compare_pstr_to_string<'a>(
     Some(s_offset)
 }
 
+#[derive(Debug)]
 pub struct Ball {
     pub(super) boundary: usize,
     pub(super) stub: Heap,
@@ -357,6 +360,7 @@ impl Ball {
     }
 }
 
+#[derive(Debug)]
 pub(super) struct CopyTerm<'a> {
     state: &'a mut MachineState,
 }
@@ -404,6 +408,7 @@ impl<'a> CopierTarget for CopyTerm<'a> {
     }
 }
 
+#[derive(Debug)]
 pub(super) struct CopyBallTerm<'a> {
     stack: &'a mut Stack,
     heap: &'a mut Heap,
@@ -529,13 +534,13 @@ impl IndexMut<RegType> for MachineState {
 
 pub type Registers = Vec<Addr>;
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub(super) enum MachineMode {
     Read,
     Write,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub(super) enum HeapPtr {
     HeapCell(usize),
     PStrChar(usize, usize),
@@ -576,6 +581,7 @@ impl Default for HeapPtr {
     }
 }
 
+#[derive(Debug)]
 pub struct MachineState {
     pub(super) s: HeapPtr,
     pub(super) p: CodePtr,
@@ -934,7 +940,7 @@ fn try_in_situ(
 
 pub(crate) type CallResult = Result<(), Vec<HeapCellValue>>;
 
-pub(crate) trait CallPolicy: Any {
+pub(crate) trait CallPolicy: Any + fmt::Debug {
     fn retry_me_else(&mut self, machine_st: &mut MachineState, offset: usize) -> CallResult {
         let b = machine_st.b;
         let n = machine_st.stack.index_or_frame(b).prelude.univ_prelude.num_cells;
@@ -1517,10 +1523,12 @@ impl CallPolicy for CWILCallPolicy {
 
 downcast!(dyn CallPolicy);
 
+#[derive(Debug)]
 pub(crate) struct DefaultCallPolicy {}
 
 impl CallPolicy for DefaultCallPolicy {}
 
+#[derive(Debug)]
 pub(crate) struct CWILCallPolicy {
     pub(crate) prev_policy: Box<dyn CallPolicy>,
     count: Integer,
@@ -1601,7 +1609,7 @@ impl CWILCallPolicy {
     }
 }
 
-pub(crate) trait CutPolicy: Any {
+pub(crate) trait CutPolicy: Any + fmt::Debug {
     // returns true iff we fail or cut redirected the MachineState's p itself
     fn cut(&mut self, machine_st: &mut MachineState, r: RegType) -> bool;
 }
@@ -1627,6 +1635,7 @@ fn cut_body(machine_st: &mut MachineState, addr: &Addr) -> bool {
     false
 }
 
+#[derive(Debug)]
 pub(crate) struct DefaultCutPolicy {}
 
 pub(super) fn deref_cut(machine_st: &mut MachineState, r: RegType) {
@@ -1641,6 +1650,7 @@ impl CutPolicy for DefaultCutPolicy {
     }
 }
 
+#[derive(Debug)]
 pub(crate) struct SCCCutPolicy {
     // locations of cleaners, cut points, the previous block
     cont_pts: Vec<(Addr, usize, usize)>,

src/prolog/machine/mod.rs

@@ -53,6 +53,7 @@ use std::path::PathBuf;
 use std::rc::Rc;
 use std::sync::atomic::AtomicBool;
 
+#[derive(Debug)]
 pub struct MachinePolicies {
     call_policy: Box<dyn CallPolicy>,
     cut_policy: Box<dyn CutPolicy>,
@@ -79,6 +80,7 @@ impl Default for MachinePolicies {
     }
 }
 
+#[derive(Debug)]
 pub struct Machine {
     pub(super) machine_st: MachineState,
     pub(super) inner_heap: Heap,

src/prolog/machine/partial_string.rs

@@ -7,6 +7,7 @@ use std::ops::RangeFrom;
 use std::slice;
 use std::str;
 
+#[derive(Debug)]
 pub struct PartialString {
     buf: *const u8,
     len: usize,
@@ -46,6 +47,7 @@ fn scan_for_terminator<Iter: Iterator<Item = char>>(iter: Iter) -> usize {
     terminator_idx
 }
 
+#[derive(Debug)]
 pub struct PStrIter {
     buf: *const u8,
     len: usize,

src/prolog/machine/raw_block.rs

@@ -14,6 +14,7 @@ pub(crate) trait RawBlockTraits {
     }
 }
 
+#[derive(Debug)]
 pub(crate) struct RawBlock<T: RawBlockTraits> {
     pub(crate) size: usize,
     pub(crate) base: *const u8,

src/prolog/machine/stack.rs

@@ -7,6 +7,7 @@ use std::mem;
 use std::ops::{Index, IndexMut};
 use std::ptr;
 
+#[derive(Debug)]
 struct StackTraits {}
 
 impl RawBlockTraits for StackTraits {
@@ -35,6 +36,7 @@ const fn prelude_size<Prelude>() -> usize {
     (size & !(align - 1)) + align
 }
 
+#[derive(Debug)]
 pub struct Stack {
     buf: RawBlock<StackTraits>,
     _marker: PhantomData<Addr>,
@@ -47,11 +49,12 @@ impl Drop for Stack {
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub struct FramePrelude {
     pub num_cells: usize,
 }
 
+#[derive(Debug)]
 pub struct AndFramePrelude {
     pub univ_prelude: FramePrelude,
     pub e: usize,
@@ -59,6 +62,7 @@ pub struct AndFramePrelude {
     pub interrupt_cp: LocalCodePtr,
 }
 
+#[derive(Debug)]
 pub struct AndFrame {
     pub prelude: AndFramePrelude,
 }
@@ -99,6 +103,7 @@ impl IndexMut<usize> for AndFrame {
     }
 }
 
+#[derive(Debug)]
 pub struct OrFramePrelude {
     pub univ_prelude: FramePrelude,
     pub e: usize,
@@ -113,6 +118,7 @@ pub struct OrFramePrelude {
     pub attr_var_init_bindings_b: usize,
 }
 
+#[derive(Debug)]
 pub struct OrFrame {
     pub prelude: OrFramePrelude,
 }

src/prolog/machine/streams.rs

@@ -11,13 +11,13 @@ use std::hash::{Hash, Hasher};
 use std::net::TcpStream;
 use std::rc::Rc;
 
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum StreamType {
     Binary,
     Text,
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum EOFAction {
     EOFCode,
     Error,
@@ -37,7 +37,26 @@ pub enum StreamInstance {
     TcpStream(TcpStream),
 }
 
-#[derive(Clone)]
+impl fmt::Debug for StreamInstance {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            &StreamInstance::Bytes(ref bytes) =>
+                write!(fmt, "Bytes({:?})", bytes),
+            &StreamInstance::DynReadSource(_) =>
+                write!(fmt, "DynReadSource(_)"),  // Hacky solution.
+            &StreamInstance::File(ref file) => write!(fmt, "File({:?})", file),
+            &StreamInstance::Null => write!(fmt, "Null"),
+            &StreamInstance::ReadlineStream(ref readline_stream) =>
+                write!(fmt, "ReadlineStream({:?})", readline_stream),
+            &StreamInstance::Stdin => write!(fmt, "Stdin"),
+            &StreamInstance::Stdout => write!(fmt, "Stdout"),
+            &StreamInstance::TcpStream(ref tcp_stream) =>
+                write!(fmt, "TcpStream({:?})", tcp_stream),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
 struct WrappedStreamInstance(Rc<RefCell<StreamInstance>>);
 
 impl WrappedStreamInstance {
@@ -95,7 +114,7 @@ impl fmt::Display for StreamError {
 
 impl Error for StreamError {}
 
-#[derive(Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct StreamOptions {
     pub stream_type: StreamType,
     pub reposition: bool,
@@ -115,7 +134,7 @@ impl Default for StreamOptions {
     }
 }
 
-#[derive(Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Stream {
     pub options: StreamOptions,
     stream_inst: WrappedStreamInstance,

src/prolog/machine/system_calls.rs

@@ -24,8 +24,9 @@ use indexmap::IndexSet;
 
 use std::cmp;
 use std::convert::TryFrom;
-use std::io::{stdout, Write};
+use std::io::{stdout, Read, Write};
 use std::iter::once;
+use std::fs::File;
 use std::rc::Rc;
 
 use std::time::Duration;
@@ -60,6 +61,7 @@ pub fn get_single_char() -> char {
     c
 }
 
+#[derive(Debug)]
 struct BrentAlgState {
     hare: Addr,
     tortoise: Addr,
@@ -1519,6 +1521,90 @@ impl MachineState {
                     }
                 };
             }
+            &SystemClauseType::FileToChars => {
+                // TODO: Replace this with stream.
+                use std::io;
+                let a1 = self.store(self.deref(self[temp_v!(1)]));
+                let a2 = self.store(self.deref(self[temp_v!(2)]));
+
+                let file_name = match a1 {
+                    Addr::Con(h) if self.heap.atom_at(h) => {
+                        if let HeapCellValue::Atom(name, _) = &self.heap[h] {
+                            name.as_str().to_string()
+                        }
+                        else {
+                            unreachable!()
+                        }
+                    }
+                    Addr::Char(c) => {
+                        c.to_string()
+                    }
+                    _ => unreachable!()
+                };
+                let name = clause_name!("$file_to_chars");
+                let mut file = match File::open(&file_name) {
+                    Ok(f) => f,
+                    Err(e) => {
+                        let file_name_ = clause_name!(file_name.clone(),
+                            indices.atom_tbl.clone());
+                        let arity = 2;
+                        let stub = MachineError::functor_stub(name.clone(), arity);
+                        let h = self.heap.h();
+                        let err = match e.kind() {
+                            io::ErrorKind::NotFound => {
+                                MachineError::existence_error(
+                                    h,
+                                    ExistenceError::SourceSink(
+                                        ModuleSource::File(file_name_)
+                                    ),
+                                )
+                            }
+                            io::ErrorKind::PermissionDenied => {
+                                let stub = MachineError::functor_stub(
+                                    name.clone(),
+                                    arity
+                                );
+                                let source_sink = self.store(self.deref(a1));
+                                MachineError::permission_error(
+                                    h,
+                                    Permission::Access,
+                                    "source_sink",
+                                    source_sink
+                                )
+                            }
+                            _ => unreachable!()  // Not nice.
+                        };
+
+                        let err = self.error_form(err, stub);
+
+                        self.throw_exception(err);
+                        return Ok(());
+                    }
+                };
+                let char_list = {
+                    let mut buffer = String::new();
+                    match file.read_to_string(&mut buffer) {
+                        Ok(_size) => {
+                            let chars = buffer.chars().map(|c| Addr::Char(c));
+                            Addr::HeapCell(self.heap.to_list(chars))
+                        }
+                        Err(_e) => {
+                            // This case if the data isn't UTF-8 valid.
+                            let mut buffer = Vec::new();
+                            let _ = match file.read_to_end(&mut buffer) {
+                                Ok(size) => size,
+                                Err(_e) => unreachable!()
+                            };
+                            let chars = buffer
+                                .into_iter()
+                                .map(|b| Addr::Char(b as char));
+                            Addr::HeapCell(self.heap.to_list(chars))
+                        }
+                    }
+                };
+
+                self.unify(char_list, a2);
+            }
             &SystemClauseType::GetChar => {
                 let mut iter = parsing_stream(current_input_stream.clone());
                 let result = iter.next();

src/prolog/machine/term_expansion.rs

@@ -47,6 +47,7 @@ fn extract_from_list(
     }
 }
 
+#[derive(Debug)]
 pub struct TermStream<'a> {
     stack: Vec<Term>,
     pub(crate) wam: &'a mut Machine,
@@ -57,6 +58,7 @@ pub struct TermStream<'a> {
     top_level_terms: Vec<(Term, usize, usize)>, // term, line_num, col_num.
 }
 
+#[derive(Debug)]
 pub struct ExpansionAdditionResult {
     term_expansion_additions: (Predicate, VecDeque<TopLevel>),
     goal_expansion_additions: (Predicate, VecDeque<TopLevel>),

src/prolog/machine/toplevel.rs

@@ -14,6 +14,7 @@ use std::borrow::BorrowMut;
 use std::cell::Cell;
 use std::collections::VecDeque;
 use std::convert::TryFrom;
+use std::fmt;
 use std::mem;
 use std::ops::DerefMut;
 use std::rc::Rc;
@@ -23,6 +24,15 @@ enum IndexSource<'a, T> {
     Local(&'a mut T)
 }
 
+impl<'a, T: fmt::Debug> fmt::Debug for IndexSource<'a, T> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            IndexSource::TermStream => write!(fmt, "TermStream"),
+            IndexSource::Local(ref local) => write!(fmt, "Local({:?})", local),
+        }
+    }
+}
+
 fn op_dir<'a, 'b: 'a>(from: &'b IndexSource<'a, IndexStore>) -> RefOrOwned<'a, OpDir> {
     match from {
         IndexSource::TermStream => RefOrOwned::Owned(OpDir::new()),
@@ -30,6 +40,7 @@ fn op_dir<'a, 'b: 'a>(from: &'b IndexSource<'a, IndexStore>) -> RefOrOwned<'a, O
     }
 }
 
+#[derive(Debug)]
 struct CompositeIndices<'a, 'b, 'c> {
     term_stream: &'b mut TermStream<'a>,
     index_src: IndexSource<'c, IndexStore>,
@@ -690,6 +701,7 @@ fn setup_declaration<'a, 'b, 'c>(
     }
 }
 
+#[derive(Debug)]
 struct RelationWorker {
     flags: MachineFlags,
     dynamic_clauses: Vec<(Term, Term)>, // Head, Body.
@@ -1141,6 +1153,7 @@ pub type DynamicClause = Vec<(Term, Term)>;
 
 pub type DynamicClauseMap = IndexMap<(ClauseName, usize), DynamicClause>;
 
+#[derive(Debug)]
 pub struct TopLevelBatchWorker<'a> {
     pub(crate) term_stream: TermStream<'a>,
     rel_worker: RelationWorker,

src/prolog/read.rs

@@ -35,6 +35,7 @@ pub mod readline {
         }
     }
 
+    #[derive(Debug)]
     pub struct ReadlineStream {
         rl: Editor<()>,
         pending_input: Cursor<String>,
@@ -114,12 +115,14 @@ fn write_term_to_heap(term: &Term, machine_st: &mut MachineState) -> TermWriteRe
     term_writer.write_term_to_heap(term)
 }
 
+#[derive(Debug)]
 struct TermWriter<'a> {
     machine_st: &'a mut MachineState,
     queue: SubtermDeque,
     var_dict: HeapVarDict,
 }
 
+#[derive(Debug)]
 pub struct TermWriteResult {
     pub(crate) heap_loc: usize,
     pub(crate) var_dict: HeapVarDict,