reconcile '[]' and [] (#644), solve remaining conformity issues (#648), move (-->) from dcgs.pl to builtins.pl (#649)

Improved readline

.dockerignore

@@ -0,0 +1,6 @@
+target
+Dockerfile
+README.md
+.git
+.gitignore
+.gitmodules

.travis.yml

@@ -1,14 +1,31 @@
 language: rust
-rust:
-    - stable
-    - beta
-    - nightly
-matrix:
-    allow_failures:
-        - rust: nightly
-    fast_finish: true
+cache: cargo
+os: linux
+dist: xenial
 
-script:
-    - cargo build --verbose --all
-    - cargo test --verbose --all
-    - cargo test --verbose --all --no-default-features --features num
+before_script:
+  - cargo fetch
+
+jobs:
+  allow_failures:
+    env:
+      - CAN_FAIL=true
+  include:
+  - stage: "Stable: Build"
+    rust: stable
+    script: cargo rustc --verbose -- -D warnings
+    name: "Build Stable"
+  - stage: "Stable: Tests"
+    rust: stable
+    script: cargo test --verbose --all
+    name: "Tests Stable"
+  - stage: "Features"
+    rust: stable
+    script: cargo test --verbose --all --no-default-features --features num
+    name: "num Tests"
+    env: CAN_FAIL=true
+  - stage: "Beta: Build"
+  # - #
+    rust: beta
+    script: cargo rustc --verbose -- -D warnings
+    name: "Build Beta"

Cargo.toml

@@ -1,12 +1,15 @@
 [package]
 name = "scryer-prolog"
-version = "0.8.118"
+version = "0.8.127"
 authors = ["Mark Thom <markjordanthom@gmail.com>"]
-build = "build.rs"
-repository = "https://github.com/mthom/scryer-prolog"
-description = "A modern Prolog implementation written mostly in Rust."
-license = "BSD-3-Clause"
 edition = "2018"
+description = "A modern Prolog implementation written mostly in Rust."
+readme = "README.md"
+repository = "https://github.com/mthom/scryer-prolog"
+license = "BSD-3-Clause"
+keywords = ["prolog", "prolog-interpreter", "prolog-system"]
+categories = ["command-line-utilities"]
+build = "build.rs"
 
 [build-dependencies]
 indexmap = "1.0.2"
@@ -16,17 +19,32 @@ default = ["rug", "prolog_parser/rug"]
 num = ["num-rug-adapter", "prolog_parser/num"]
 
 [dependencies]
+cpu-time = "1.0.0"
 crossterm = "0.16.0"
 dirs = "2.0.2"
+divrem = "0.1.0"
 downcast = "0.10.0"
 git-version = "0.3.4"
+hostname = "0.3.1"
 indexmap = "1.0.2"
 lazy_static = "1.4.0"
 libc = "0.2.62"
 nix = "0.15.0"
-num-rug-adapter = { optional = true, version = "0.1.1" }
+num-rug-adapter = { optional = true, version = "0.1.3" }
 ordered-float = "0.5.0"
-prolog_parser = { version = "0.8.49", default-features = false }
+prolog_parser = { version = "0.8.65", default-features = false }
 ref_thread_local = "0.0.0"
 rug = { version = "1.4.0", optional = true }
-rustyline = "6.0.0"
+rustyline = "6.0.0"
+unicode_reader = "1.0.0"
+ring = "0.16.13"
+ripemd160 = "0.8.0"
+sha3 = "0.8.2"
+blake2 = "0.8.1"
+openssl = { version = "0.10.29", features = ["vendored"] }
+native-tls = "0.2.4"
+chrono = "0.4.11"
+select = "0.4.3"
+roxmltree = "0.11.0"
+base64 = "0.12.3"
+sodiumoxide = "0.2.6"

Dockerfile

@@ -0,0 +1,30 @@
+# Based on https://hub.docker.com/_/rust?tab=description and https://blog.sedrik.se/posts/my-docker-setup-for-rust/
+
+# The first container is for build purposes only.
+FROM rust as builder
+
+WORKDIR /usr/src/scryer-prolog
+
+# Using a dummy build.rs and src/main.rs with your Cargo.toml lets Docker cache your Rust dependencies and not rebuild
+# them every time.
+COPY Cargo.toml .
+COPY Cargo.lock .
+RUN mkdir -p src
+RUN echo "fn main() {}" > src/main.rs
+RUN echo "fn main() {}" > build.rs
+RUN cargo build --release
+
+# We need to touch our real main.rs and build.rs files or else
+# docker will use the cached ones.
+COPY . .
+RUN touch src/main.rs
+RUN touch build.rs
+
+RUN cargo build --release
+
+RUN ls ./target/release
+
+# Finally, copy the scryer-prolog executable to a slimmer container.
+FROM debian:buster-slim
+COPY --from=builder /usr/src/scryer-prolog/target/release/scryer-prolog /usr/local/bin/scryer-prolog
+CMD ["scryer-prolog"]

README.md

@@ -5,6 +5,8 @@ source industrial strength production environment that is also a
 testbed for bleeding edge research in logic and constraint
 programming, which is itself written in a high-level language.
 
+![Scryer Logo: Cryer](logo/scryer.png)
+
 ## Phase 1
 
 Produce an implementation of the Warren Abstract Machine in Rust, done
@@ -40,7 +42,7 @@ Extend Scryer Prolog to include the following, among other features:
   - [x] Support for `verify_attributes/3`
   - [x] Support for `attribute_goals/2` and `project_attributes/2`
   - [x] `call_residue_vars/2`
-- [x] `if_` and related predicates, following the developments of the
+- [x] `if_/3` and related predicates, following the developments of the
       paper "Indexing `dif/2`".
 - [x] All-solutions predicates (`findall/{3,4}`, `bagof/3`, `setof/3`, `forall/2`).
 - [x] Clause creation and destruction (`asserta/1`, `assertz/1`,
@@ -55,7 +57,10 @@ Extend Scryer Prolog to include the following, among other features:
 - [x] A _redone_ representation of strings as difference lists of
       characters, using a packed internal representation.
 - [x] clp(B) and clp(ℤ) as builtin libraries.
-- [ ] Streams and predicates for stream control (_in progress_).
+- [x] Streams and predicates for stream control.
+  - [x] A simple sockets library representing TCP connections as streams.  
+- [ ] Incremental compilation and loading process, newly written,
+      primarily in Prolog. (_in progress_)
 - [ ] A compacting garbage collector satisfying the five
       properties of "Precise Garbage Collection in Prolog."
 - [ ] Mode declarations.
@@ -90,6 +95,8 @@ strings.
 
 ## Installing Scryer Prolog
 
+### Native Install (Unix Only)
+
 First, install the latest stable version of
 [Rust](https://www.rust-lang.org/en-US/install.html) using your
 preferred method. Scryer tends to use features from newer Rust
@@ -123,62 +130,85 @@ $> cargo run [--release]
 The optional `--release` flag will perform various optimizations,
 producing a faster executable.
 
+### Docker Install (All Platforms)
+
+First, install [Docker](https://docs.docker.com/get-docker/) on Linux,
+Windows, or Mac.
+
+Once Docker is installed, you can download and run Scryer Prolog with a single
+command:
+```
+$> docker run -it mjt128/scryer-prolog
+```
+
+To consult your Prolog files, bind mount your programs folder as a
+[Docker volume](https://docs.docker.com/storage/volumes/):
+
+```
+$> docker run -v /home/user/prolog:/mnt -it mjt128/scryer-prolog
+?- consult('/mnt/program.pl').
+true.
+```
+
+This works on Windows too:
+
+```
+$> docker run -v C:\Users\user\Documents\prolog:/mnt -it mjt128/scryer-prolog
+?- consult('/mnt/program.pl').
+true.
+```
+
 ## Tutorial
-To enter a multi-clause predicate, the directive "[user]" is used.
 
-For example,
-```
-?- [user].
-(type Enter + Ctrl-D to terminate the stream when finished)
-p(f(f(X)), h(W), Y) :- g(W), h(W), f(X).
-p(X, Y, Z) :- h(Y), z(Z).
-?- [user].
-(type Enter + Ctrl-D to terminate the stream when finished)
-h(x). h(y).
-h(z).
-```
-In the example, `Enter + Ctrl-D` is used to terminate the standard
-input stream. The instructive message is always printed.
+Prolog files are loaded by specifying them as arguments on the command
+line. For example, to load `program.pl`, use:
 
-Queries are issued as
 ```
-?- p(X, Y, Z).
+$> scryer-prolog program.pl
 ```
 
-Pressing `SPACE` will backtrack through other possible answers, if any exist.
-Pressing `.` will abort the search and return to the prompt.
+Loading a Prolog file is also called “consulting” it. The built-in
+predicate `consult/1` can be used to consult a file from within
+Prolog:
 
-Wildcards work as well:
+```
+?- consult('program.pl').
+```
+
+As an abbreviation for `consult/1`, you can specify a *list* of
+program files, given as *atoms*:
+
+```
+?- ['program.pl'].
+```
+
+The special notation `[user]` is used to read Prolog text from
+standard input. For example,
 
 ```
 ?- [user].
-(type Enter + Ctrl-D to terminate the stream when finished)
-member(X, [X|_]).
-member(X, [_|Xs]) :- member(X, Xs).
-?- member(X, [a, b, c]).
-   X = a
-;  X = b
-;  X = c
-;  false.
-```
-and so do conjunctive queries:
-```
-?- [user].
-(type Enter + Ctrl-D to terminate the stream when finished)
-f(X) :- g(X).
-g(x). g(y). g(z).
-h(call(f, X)).
-?- h(X), X.
-   X = call(f,x)
-;  X = call(f,y)
-;  X = call(f,z).
+hello(declarative_world).
+hello(pure_world).
 ```
 
-Note that the values of variables belonging to successful queries are
-printed out, on one line each. Uninstantiated variables are denoted by
-a number preceded by an underscore (`X = _0` in an example above).
+Pressing `RETURN` followed by `Ctrl-d` stops reading from
+standard input and consults the entered Prolog text.
+
+After a program is consulted, you can ask *queries* about the
+predicates it defines. For example, with the program shown above:
+
+```
+?- hello(What).
+   What = declarative_world
+;  What = pure_world.
+```
+
+Press `SPACE` to show further answers, if any exist. Press `RETURN` or
+ `.` to abort the search and return to the toplevel prompt.
+Press `h` to show a help message.
+
+To quit Scryer Prolog, use the standard predicate `halt/0`:
 
-To quit scryer-prolog, type
 ```
 ?- halt.
 ```
@@ -190,8 +220,8 @@ arithmetic operators with the usual precedences,
 
 ```
 ?- write_canonical(-5 + 3 - (2 * 4) // 8), nl.
-   -(+(-5,3),//(*(2,4),8))
-true.
+-(+(-5,3),//(*(2,4),8))
+   true.
 ```
 
 New operators can be defined using the `op` declaration.
@@ -241,15 +271,75 @@ the above example, posting <tt>Ls0&nbsp;=&nbsp;[a,b,c|Ls]</tt> yields
 the exact same internal representation, and has the advantage that
 only the standard predicate&nbsp;`(=)/2` is used.
 
-Definite clause grammars as provided by `library(dcgs)` are ideally
-suited for reasoning about strings.
+Definite clause grammars as provided by
+[`library(dcgs)`](src/lib/lists.pl), and the predicates from
+[`library(lists)`](src/lib/lists.pl), are ideally suited for reasoning
+about strings.
+
+Partial strings were first proposed by Ulrich Neumerkel in issue
+[#95](https://github.com/mthom/scryer-prolog/issues/95).
+
+### Tabling (SLG resolution)
+
+One of the foremost attractions of Prolog is that logical consequences
+of pure&nbsp;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&nbsp;execution and
+SLG&nbsp;resolution. To enable tabled execution for a predicate, use
+[`library(tabling)`](src/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&nbsp;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&nbsp;et.&nbsp;al.
+
+### Constraint Logic Programming (CLP)
+
+Scryer Prolog provides excellent support for Constraint Logic
+Programming&nbsp;(CLP), which is the amalgamation of
+Logic&nbsp;Programming&nbsp;(LP) and Constraints.
+
+In addition to built-in support for [`dif/2`](src/lib/dif.pl),
+[`freeze/2`](src/lib/freeze.pl),
+[CLP(B)](src/lib/clpb.pl) and [CLP(ℤ)](src/lib/clpz.pl),
+Scryer provides a convenient way to implement new user-defined
+constraints: *Attributed variables* are available via
+[`library(atts)`](src/lib/atts.pl) as in SICStus&nbsp;Prolog,
+which is one of the most sophisticated and fastest constraint systems
+in existence. In [`library(iso_ext)`](src/lib/iso_ext.pl),
+Scryer provides predicates for backtrackable (`bb_b_put/2`) and
+non-backtrackable (`bb_put/2`) global variables, which are needed to
+implement certain types of constraint&nbsp;solvers.
+
+These features make Scryer Prolog an ideal platform for teaching,
+learning and developing portable CLP&nbsp;applications.
 
 ### Modules
 
 Scryer has a simple predicate-based module system. It provides a
 way to separate units of code into distinct namespaces, for both
 predicates and operators. See the files
-[`src/prolog/lib/*.pl`](src/prolog/lib) for
+[`src/lib/*.pl`](src/lib) for
 examples.
 
 At the time of this writing, many predicates reside in their own
@@ -257,31 +347,31 @@ modules that need to be imported before they can be used.
 The modules that ship with Scryer&nbsp;Prolog are also called
 *library*&nbsp;modules or *libraries*, and include:
 
-* [`lists`](src/prolog/lib/lists.pl)
+* [`lists`](src/lib/lists.pl)
   providing `length/2`, `member/2`, `select/3`, `append/[2,3]`,
   `foldl/[4,5]`, `maplist/[2-9]`, `same_length/2`, `transpose/2` etc.
-* [`dcgs`](src/prolog/lib/dcgs.pl)
+* [`dcgs`](src/lib/dcgs.pl)
   Definite Clause Grammars (DCGs), a built-in grammar mechanism
   that uses the operator `(-->)/2` to define grammar rules,
   and the predicates `phrase/[2,3]` to invoke them.
-* [`dif`](src/prolog/lib/dif.pl)
+* [`dif`](src/lib/dif.pl)
   The predicate `dif/2` provides declarative disequality:
   It is true if and only if its arguments are different, and
   delays the test until a sound decision can be made.
-* [`reif`](src/prolog/lib/reif.pl)
+* [`reif`](src/lib/reif.pl)
   providing `if_/3`, `tfilter/3` and related predicates
   as described in *Indexing&nbsp;dif/2*.
-* [`clpz`](src/prolog/lib/clpz.pl)
+* [`clpz`](src/lib/clpz.pl)
   CLP(ℤ): Constraint Logic Programming over Integers,
   providing declarative integer arithmetic via `(#=)/2`, `(#\=)/2`,
   `(#>=)/2` etc., and various global constraints and
   enumeration predicates for solving combinatorial tasks.
-* [`pairs`](src/prolog/lib/pairs.pl)
+* [`pairs`](src/lib/pairs.pl)
   By convention, *pairs* are Prolog terms with
   principal&nbsp;functor `(-)/2`, written as `Key-Value`.
   This library provides `pairs_keys_values/3`,
   `pairs_keys/2`, and other predicates to reason about pairs.
-* [`si`](src/prolog/lib/si.pl)
+* [`si`](src/lib/si.pl)
   The predicates `atom_si/1`, `integer_si/1`, `atomic_si/1`
   and `list_si/1` implement sound type checks. They raise
   instantiation errors if no decision can be made.
@@ -290,25 +380,84 @@ The modules that ship with Scryer&nbsp;Prolog are also called
   write `integer_si(X)` to ensure soundness of your programs.
   "si" stands for *sufficiently instantiated*, and also for
   *sound&nbsp;inference*.
-* [`error`](src/prolog/lib/error.pl)
-  `must_be/2` and `can_be/2` complement the type checks provided
-  by `library(si)`, and are especially useful for Prolog library
-  authors.
-* [`tabling`](src/prolog/lib/tabling.pl)
+* [`debug`](src/lib/debug.pl)
+  Various predicates that allow for declarative debugging.
+* [`pio`](src/lib/pio.pl)
+  `phrase_from_file/2` applies a DCG nonterminal to the contents of a
+  file, reading lazily only as much as is needed. Due to the compact
+  internal string representation, also extremely large files can be
+  efficiently processed with Scryer&nbsp;Prolog in this way.
+* [`charsio`](src/lib/charsio.pl) Various predicates that are useful
+  for parsing and reasoning about characters, notably `char_type/2` to
+  classify characters according to their type, and conversion
+  predicates for different encodings of strings.
+* [`error`](src/lib/error.pl)
+  `must_be/2` and `can_be/2` complement the type checks provided by
+  [`library(si)`](src/lib/si.pl), and are especially useful for
+  Prolog library authors.
+* [`tabling`](src/lib/tabling.pl)
   The operator `(table)/1` is used in directives that prepare
   predicates for tabled execution (SLG&nbsp;resolution).
-* [`format`](src/prolog/lib/format.pl)
+* [`format`](src/lib/format.pl)
   The nonterminal `format_//2` is used to describe formatted output,
   arranging arguments according to a given format&nbsp;string.
-  The predicate `format/2` is provided for impure output.
-* [`assoc`](src/prolog/lib/assoc.pl)
+  The predicates `format/[2,3]`, `portray_clause/[1,2]` and `listing/1`
+  provide formatted *impure* output.
+* [`assoc`](src/lib/assoc.pl)
   providing `empty_assoc/1`, `get_assoc/3`, `put_assoc/4` etc.
   to manage elements in AVL&nbsp;trees which ensure
   *O*(log(*N*))&nbsp;access.
-* [`clpb`](src/prolog/lib/clpb.pl)
+* [`ordsets`](src/lib/ordsets.pl)
+  represents ordered sets as lists.
+* [`clpb`](src/lib/clpb.pl)
   CLP(B): Constraint Logic Programming over Boolean variables,
   a BDD-based SAT&nbsp;solver provided via the predicates
   `sat/1`, `taut/2`, `labeling/1` etc.
+* [`arithmetic`](src/lib/arithmetic.pl)
+  Arithmetic predicates such as `lsb/2`, `msb/2` and
+  `number_to_rational/2`.
+* [`time`](src/lib/time.pl) Predicates for reasoning about
+  time, including `time/1` to measure the CPU&nbsp;time of a goal,
+  `current_time/1` to obtain the current system time, the nonterminal
+  `format_time//2` to describe strings with dates and times, and
+  `sleep/1` to slow down a computation.
+* [`files`](src/lib/files.pl)
+  Predicates for reasoning about files and directories, such as
+  `directory_files/2`, `file_exists/1` and `file_size/2`.
+* [`cont`](src/lib/cont.pl)
+  Provides *delimited continuations* via `reset/3` and `shift/1`.
+* [`random`](src/lib/random.pl)
+  Probabilistic predicates and random number generators.
+* [`http/http_open`](src/lib/http/http_open.pl) Open a stream to
+  read answers from web&nbsp;servers. HTTPS is also supported.
+* [`sgml`](src/lib/sgml.pl)
+  `load_html/3` and `load_xml/3` represent HTML and XML&nbsp;documents
+  as Prolog&nbsp;terms for convenient and efficient reasoning. Use
+  [`library(xpath)`](src/lib/iso_ext.pl) to extract information from
+  parsed documents.
+* [`csv`](src/lib/csv.pl)
+  `parse_csv//1` and `parse_csv//2` can be used with [`phrase_from_file/2`](src/lib/pio.pl)
+  or [`phrase/2`](src/lib/dcgs.pl) to parse csv
+* [`xpath`](src/lib/xpath.pl)
+  The predicate `xpath/3` is used for convenient reasoning about HTML
+  and XML&nbsp;documents, inspired by the XPath language. This library
+  is often used together with [`library(sgml)`](src/lib/sgml.pl).
+* [`sockets`](src/lib/sockets.pl)
+  Predicates for opening and accepting TCP connections as streams.
+  TLS negotiation is performed via the option `tls(true)` in
+  `socket_client_open/3`, yielding secure encrypted connections.
+* [`os`](src/lib/os.pl)
+  Predicates for reasoning about environment&nbsp;variables.
+* [`iso_ext`](src/lib/iso_ext.pl)
+  Conforming extensions to and candidates for inclusion in the Prolog
+  ISO&nbsp;standard, such as `setup_call_cleanup/3` and
+  `call_with_inference_limit/3`.
+* [`crypto`](src/lib/crypto.pl)
+  Cryptographically secure random numbers and hashes, HMAC-based key
+  derivation&nbsp;(HKDF), password-based key derivation&nbsp;(PBKDF2),
+  public key signatures and signature verification with&nbsp;Ed25519,
+  ECDH key&nbsp;exchange over Curve25519 (X25519), authenticated symmetric
+  encryption with ChaCha20-Poly1305, and reasoning about elliptic curves.
 
 To use predicates provided by the `lists` library, write:
 
@@ -345,7 +494,6 @@ REPL:
 
 ```
 ?- [user].
-(type Enter + Ctrl-D to terminate the stream when finished)
 :- module(test, [local_member/2]).
 :- use_module(library(lists)).
 
@@ -354,3 +502,17 @@ local_member(X, Xs) :- member(X, Xs).
 
 The user listing can also be terminated by placing `end_of_file.` at
 the end of the stream.
+
+### Configuration file
+
+At startup, Scryer Prolog consults the file `~/.scryerrc`, if the file
+exists. This file is useful to automatically load libraries and define
+predicates that you need often.
+
+For example, a sensible starting point for `~/.scryerrc` is:
+
+```
+:- use_module(library(lists)).
+:- use_module(library(dcgs)).
+:- use_module(library(reif)).
+```

build.rs

@@ -1,60 +1,55 @@
 extern crate indexmap;
 
-use indexmap::IndexSet;
-
 use std::env;
-use std::fs::{File, copy, read_dir};
+use std::fs;
+use std::fs::File;
 use std::io::Write;
 use std::path::Path;
 
-fn main()
-{
+fn find_prolog_files(libraries: &mut File, prefix: &str, current_dir: &Path) {
+    let entries = match current_dir.read_dir() {
+        Ok(entries) => entries,
+        Err(_) => return,
+    };
+    for entry in entries.filter_map(Result::ok).map(|e| e.path()) {
+        if entry.is_dir() {
+            if let Some(file_name) = entry.file_name() {
+                let new_prefix =
+                    prefix.to_owned() + file_name.to_str().unwrap() + "/";
+                find_prolog_files(libraries, &new_prefix, &entry);
+            }
+        } else if entry.is_file() {
+            let ext = std::ffi::OsStr::new("pl");
+            if entry.extension() == Some(ext) {
+                let contain =
+                    String::from_utf8(fs::read(&entry).unwrap()).unwrap();
+                let name = entry.file_stem().unwrap().to_str().unwrap();
+                let line = format!(
+                    "        m.insert(\"{}\",\n{:?});\n",
+                    prefix.to_owned() + name,
+                    contain
+                );
+
+                libraries.write_all(line.as_bytes()).unwrap();
+            }
+        }
+    }
+}
+
+fn main() {
     let out_dir = env::var("OUT_DIR").unwrap();
     let dest_path = Path::new(&out_dir).join("libraries.rs");
 
     let mut libraries = File::create(&dest_path).unwrap();
-    let mut library_index = IndexSet::new();
+    let lib_path = Path::new("src/lib");
 
-    let paths = read_dir("./src/prolog/lib").unwrap();
-
-    for item in paths {
-        let item = item.unwrap().path();
-
-        if let Some(file_name) = item.file_name() {
-            if let Some(ext) = item.extension() {
-                if ext == "pl" {
-                    let file_stem = item.file_stem().unwrap();
-                    let file_str  = file_stem.to_string_lossy().to_uppercase();
-                    let dest = Path::new(&out_dir).join(file_name);
-
-                    match copy(&item, dest) {
-                        Ok(_) => {},
-                        Err(e) => panic!("die: {:?}", e)
-                    };
-
-                    let include_line = format!("static {}: &str = include_str!(\"{}.pl\");\n",
-                                               file_str, file_stem.to_string_lossy());
-
-                    libraries.write_all(include_line.as_bytes()).unwrap();
-                    library_index.insert(file_stem.to_string_lossy().to_string());
-                }
-            }
-        }
-    }
-
-    libraries.write_all(b"\nref_thread_local! {
+    libraries
+        .write_all(
+            b"ref_thread_local! {
     pub static managed LIBRARIES: IndexMap<&'static str, &'static str> = {
-        let mut m = IndexMap::new();\n").unwrap();
-
-    for item in library_index {
-        let line = format!("\n        m.insert(\"{}\", {});", item, item.to_uppercase());
-        libraries.write_all(line.as_bytes()).unwrap();
-    }
-
-    libraries.write_all(b"\n\n        m\n    };
-}\n").unwrap();
-
-    libraries.write_all(b"\npub static PROJECT_DIR: &'static str = \"").unwrap();
-    libraries.write_all(env::var("CARGO_MANIFEST_DIR").unwrap().as_bytes()).unwrap();
-    libraries.write_all(b"\";\n").unwrap();
+        let mut m = IndexMap::new();\n",
+        )
+        .unwrap();
+    find_prolog_files(&mut libraries, "", &lib_path);
+    libraries.write_all(b"\n        m\n    };\n}\n").unwrap();
 }

logo/scryer.svg

@@ -0,0 +1,896 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
+ "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
+<svg version="1.0" xmlns="http://www.w3.org/2000/svg"
+ width="300.000000pt" height="300.000000pt" viewBox="0 0 300.000000 300.000000"
+ preserveAspectRatio="xMidYMid meet">
+<path fill="#57d3de" d="M0 0 h 300 v 300 h -300 z"/>
+<g transform="translate(0.000000,300.000000) scale(0.100000,-0.100000)"
+fill="#800080" stroke="none">
+<path d="M2388 2423 c7 -3 16 -2 19 1 4 3 -2 6 -13 5 -11 0 -14 -3 -6 -6z"/>
+<path d="M2436 2422 c-3 -5 8 -6 25 -4 16 2 29 6 29 8 0 8 -49 4 -54 -4z"/>
+<path d="M2310 2416 c0 -10 28 -13 41 -5 10 6 7 9 -13 9 -16 0 -28 -2 -28 -4z"/>
+<path d="M2501 2415 c3 -2 23 -7 45 -9 86 -10 151 -37 181 -75 8 -10 12 -11
+13 -4 0 19 -81 69 -130 80 -50 11 -117 16 -109 8z"/>
+<path d="M2055 2373 c-60 -13 -126 -27 -145 -30 -19 -3 -38 -11 -42 -17 -6 -8
+-10 -7 -17 2 -7 11 -19 12 -62 3 -30 -6 -82 -12 -116 -14 -46 -1 -63 -6 -66
+-18 -5 -20 -107 -27 -107 -7 0 9 -3 9 -12 0 -19 -19 -41 -15 -33 6 4 11 3 13
+-3 7 -6 -5 -12 -19 -14 -30 -2 -11 -9 -19 -16 -18 -6 2 -9 -4 -6 -12 5 -11 11
+-12 24 -5 30 16 34 11 9 -9 -13 -11 -27 -15 -30 -10 -9 16 -39 -2 -39 -23 0
+-11 -5 -29 -11 -40 -14 -26 2 -37 45 -32 23 4 27 2 16 -5 -13 -9 -13 -11 3
+-12 26 -2 31 -4 44 -12 9 -6 11 -3 7 10 -5 17 -4 16 10 -1 8 -10 17 -23 18
+-28 2 -5 19 -1 39 9 22 11 34 23 31 32 -2 8 0 11 6 7 11 -6 22 16 22 42 -1 11
+-6 8 -16 -10 -8 -16 -19 -28 -24 -28 -6 0 -10 -7 -10 -15 0 -8 -4 -15 -9 -15
+-5 0 -16 -3 -25 -6 -11 -4 -16 -1 -16 10 0 16 -10 20 -42 17 -10 -1 -18 3 -18
+8 0 6 -9 11 -19 11 -47 0 -36 35 23 73 51 32 63 33 94 7 19 -16 21 -23 12 -40
+-11 -20 -21 -27 -19 -12 4 27 -2 44 -13 35 -7 -5 -26 -10 -43 -11 -64 -4 -47
+-40 25 -49 95 -13 99 89 4 107 -37 7 -37 8 -8 9 30 1 88 -21 80 -30 -2 -2 2
+-9 9 -16 10 -9 17 -7 31 9 16 18 17 21 2 15 -9 -3 -18 0 -21 6 -4 12 18 17 78
+17 20 0 38 10 57 30 15 18 33 28 41 24 8 -3 18 -1 21 5 4 6 16 6 36 -1 23 -7
+34 -7 45 2 10 8 15 9 15 2 0 -18 -34 -31 -53 -21 -11 7 -23 6 -34 -1 -17 -11
+-17 -11 0 -6 10 3 28 1 39 -5 16 -8 24 -7 41 8 12 11 29 19 37 18 8 0 22 7 31
+17 9 10 18 16 20 14 2 -2 23 -1 47 4 25 4 42 4 42 -2 0 -10 42 0 50 12 3 4 25
+15 50 23 67 24 14 19 -115 -10z m-415 -83 c0 -5 -4 -10 -10 -10 -5 0 -10 5
+-10 10 0 6 5 10 10 10 6 0 10 -4 10 -10z m82 3 c-6 -3 -9 -9 -6 -15 4 -6 1 -9
+-6 -6 -23 7 -21 24 2 25 13 0 17 -1 10 -4z"/>
+<path d="M2220 2395 c0 -7 30 -13 34 -7 3 4 -4 9 -15 9 -10 1 -19 0 -19 -2z"/>
+<path d="M2136 2328 l-21 -17 27 -1 c20 0 26 4 22 15 -5 11 0 15 17 14 13 0
+18 -3 11 -6 -19 -7 -4 -23 16 -16 15 5 15 4 2 -10 -8 -9 -26 -18 -40 -21 -14
+-2 -34 -8 -44 -12 -14 -5 -17 -4 -12 4 4 7 3 12 -2 12 -6 0 -12 -6 -15 -14 -4
+-11 -67 -30 -92 -27 -2 0 -23 -6 -46 -14 -49 -18 -62 -19 -54 -5 4 6 10 8 15
+5 4 -3 13 2 20 10 21 25 -6 17 -39 -11 -31 -26 -61 -27 -61 -1 0 7 5 18 12 25
+8 8 8 12 1 12 -6 0 -13 -7 -17 -15 -3 -8 -17 -15 -31 -15 -24 0 -30 9 -26 38
+1 6 -5 12 -14 12 -18 0 -19 -12 -3 -28 9 -9 8 -12 -7 -12 -10 0 -15 -3 -12 -7
+4 -3 1 -13 -5 -22 -9 -11 -5 -10 9 2 20 17 50 16 39 -2 -3 -4 5 -8 16 -8 26
+-2 30 -7 23 -26 -7 -16 -44 -29 -67 -24 -7 2 -10 2 -5 0 17 -10 5 -22 -20 -19
+-16 2 -22 1 -15 -1 7 -3 10 -9 7 -14 -4 -5 5 -8 19 -7 15 1 26 6 26 11 0 4 5
+5 10 2 6 -3 10 -2 10 3 0 13 70 49 110 57 19 4 78 19 130 35 52 15 114 33 137
+39 24 6 47 21 53 31 6 11 25 26 43 33 30 13 29 13 -37 13 -51 0 -74 -4 -90
+-18z"/>
+<path d="M2374 2341 c3 -5 15 -7 26 -4 28 7 25 13 -6 13 -14 0 -23 -4 -20 -9z"/>
+<path d="M1445 2329 c-194 -16 -394 -99 -536 -222 -14 -12 -72 -58 -129 -102
+-136 -106 -198 -162 -206 -189 -3 -11 -16 -32 -29 -46 -12 -14 -35 -47 -50
+-75 -15 -27 -32 -57 -39 -65 -10 -13 -9 -13 6 -1 26 20 22 5 -11 -37 -15 -20
+-42 -75 -58 -122 -17 -47 -38 -102 -47 -123 -9 -22 -12 -36 -7 -33 6 4 2 -13
+-9 -36 -26 -56 -25 -77 1 -44 11 14 17 30 14 36 -3 5 -1 10 4 10 6 0 11 -8 11
+-17 0 -15 2 -15 14 2 9 13 11 27 6 41 -11 29 -8 49 13 72 10 11 17 23 16 28
+-3 20 2 35 10 30 11 -7 23 22 15 35 -10 16 6 31 21 19 9 -8 15 -8 20 0 3 5 1
+10 -6 10 -8 0 -8 4 1 15 7 8 17 12 24 8 7 -4 6 -1 -1 9 -7 8 -10 18 -6 21 3 4
+4 7 0 7 -3 0 -13 -7 -21 -16 -17 -16 -36 -11 -36 9 0 8 3 7 9 -2 7 -11 11 -8
+16 10 4 13 16 30 27 37 10 8 15 19 11 25 -4 7 0 6 10 -2 9 -7 17 -12 18 -10 0
+2 2 19 4 37 2 19 12 40 22 48 22 16 10 18 -20 2 -12 -6 1 12 30 40 28 29 56
+52 62 52 13 0 15 27 2 34 -5 3 -8 -2 -7 -11 0 -9 -5 -18 -12 -20 -8 -3 -10 1
+-5 14 10 28 25 44 50 54 13 5 22 14 21 21 -2 6 6 14 17 16 11 2 25 9 30 14 7
+8 5 9 -5 4 -8 -4 -4 2 10 13 14 12 35 24 47 27 12 3 29 17 38 31 9 14 23 22
+30 19 9 -3 12 0 8 9 -3 9 3 18 13 21 11 4 33 17 51 30 34 26 123 43 123 24 0
+-6 5 -8 12 -4 11 7 26 10 83 18 11 2 24 -2 28 -8 6 -7 7 -6 5 4 -3 8 -15 17
+-28 20 -20 5 -21 7 -7 18 10 8 17 9 21 3 5 -7 14 -7 29 0 24 11 54 49 38 49
+-5 0 -11 -5 -13 -11 -2 -6 -23 -11 -46 -11 -23 0 -42 -4 -42 -9 0 -6 -3 -8 -7
+-6 -5 3 -14 -1 -21 -9 -11 -12 -10 -14 5 -14 16 0 16 -2 2 -15 -17 -17 -53
+-10 -42 8 4 6 1 7 -7 2 -7 -4 -28 -11 -47 -15 -29 -7 -32 -6 -22 6 7 8 14 12
+16 10 3 -3 15 7 28 22 20 24 24 25 41 12 10 -8 15 -10 11 -4 -11 19 21 51 60
+59 21 5 44 9 50 11 7 1 20 9 29 18 17 18 28 21 19 6 -3 -5 3 -10 14 -10 11 0
+23 5 26 11 4 5 18 14 32 20 13 5 22 13 19 18 -8 12 155 35 203 29 20 -3 47 -2
+61 2 39 10 -49 16 -135 9z m-940 -679 c3 -5 -1 -10 -10 -10 -9 0 -13 5 -10 10
+3 6 8 10 10 10 2 0 7 -4 10 -10z"/>
+<path d="M2490 2321 c-7 -11 -24 -21 -37 -24 -27 -5 -32 9 -5 16 15 4 15 5 -1
+6 -11 1 -21 -8 -24 -20 -5 -16 -11 -19 -30 -14 -19 4 -23 3 -17 -7 6 -10 5
+-11 -7 -1 -12 10 -19 8 -33 -8 -11 -13 -25 -19 -37 -16 -11 3 -32 -1 -47 -8
+-43 -21 -75 -29 -68 -17 4 6 -13 0 -37 -14 -25 -13 -63 -25 -86 -27 -22 -1
+-41 -5 -41 -9 0 -5 -9 -8 -20 -8 -52 0 -250 -68 -250 -86 0 -3 5 -2 10 1 6 3
+10 2 10 -4 0 -5 -4 -13 -10 -16 -5 -3 -10 -12 -9 -18 0 -9 2 -9 6 1 2 6 13 12
+23 12 10 0 22 5 25 10 4 6 11 8 16 5 5 -4 9 -1 9 4 0 6 3 10 8 10 4 -1 26 1
+49 6 32 6 40 11 36 23 -4 10 -2 13 5 8 7 -4 12 -3 12 2 0 5 6 9 13 9 38 1 102
+15 115 25 13 11 15 10 9 -4 -4 -12 -2 -15 8 -11 8 3 13 8 11 12 -2 3 9 7 25 8
+15 1 42 9 59 18 17 9 52 20 78 26 26 5 64 14 84 18 21 5 43 13 50 19 7 6 42
+15 78 22 36 6 79 16 96 21 41 12 94 11 94 -2 0 -6 -7 -17 -15 -25 -8 -9 -15
+-11 -15 -5 0 6 -7 8 -15 5 -9 -4 -15 0 -15 10 0 9 -5 16 -11 16 -7 0 -10 -12
+-7 -30 5 -34 -11 -45 -30 -21 -11 13 -13 13 -9 1 4 -15 -24 -41 -55 -53 -11
+-4 -21 0 -27 11 -10 16 -10 16 -11 0 0 -18 7 -21 43 -21 13 0 15 -3 6 -13 -14
+-16 -39 -19 -39 -3 0 5 -5 7 -11 3 -8 -4 -7 -9 2 -15 12 -8 11 -11 -1 -19 -8
+-5 -20 -10 -27 -10 -6 0 -14 -6 -17 -12 -5 -10 -7 -10 -12 0 -8 18 -24 15 -24
+-5 0 -9 -3 -14 -6 -10 -4 3 -22 -5 -41 -18 -20 -13 -44 -22 -54 -20 -11 2 -17
+0 -15 -4 3 -4 -14 -19 -37 -32 -23 -13 -54 -30 -69 -39 -103 -58 -157 -92
+-170 -107 -8 -10 -25 -45 -37 -78 -12 -33 -33 -74 -47 -92 -14 -18 -22 -33
+-18 -33 4 0 -1 -10 -12 -22 -17 -19 -56 -132 -69 -200 -2 -9 -8 -25 -13 -35
+-12 -21 -12 -22 -12 -70 0 -28 -3 -34 -10 -23 -8 12 -10 9 -10 -12 0 -14 -3
+-34 -7 -44 -5 -13 -3 -16 10 -11 14 5 17 0 17 -28 0 -18 5 -37 10 -40 16 -10
+12 -25 -7 -25 -11 0 -14 3 -7 8 8 5 6 12 -5 24 -15 15 -16 14 -15 -19 1 -19
+-2 -49 -7 -66 -5 -17 -5 -35 -1 -39 5 -5 14 9 21 31 15 53 31 61 25 14 -3 -21
+-6 -57 -8 -81 -1 -23 -8 -48 -15 -55 -10 -10 -12 -8 -9 8 4 24 -33 29 -39 5
+-4 -13 -3 -13 6 0 15 22 23 7 31 -57 6 -44 8 -50 9 -23 2 28 4 31 10 15 5 -11
+6 -25 4 -31 -2 -7 0 -29 6 -50 5 -22 13 -59 16 -83 3 -23 11 -54 16 -68 17
+-45 20 -104 7 -121 -7 -9 -8 -13 -2 -9 7 4 12 -2 12 -18 0 -14 -4 -22 -9 -19
+-5 2 -2 -11 6 -30 8 -20 15 -46 15 -59 0 -14 13 -35 30 -50 22 -20 30 -23 30
+-12 0 9 -10 20 -22 26 -18 8 -24 20 -26 51 -3 42 -3 42 18 23 20 -19 21 -19
+13 1 -4 10 -12 25 -19 31 -7 8 -10 28 -7 52 4 25 -6 84 -26 169 -27 110 -31
+147 -29 234 1 57 1 172 -1 256 -2 110 1 157 10 168 6 8 10 17 7 20 -3 3 3 37
+13 75 17 63 51 142 110 249 10 19 29 57 41 84 21 44 33 55 124 110 56 34 144
+81 195 105 127 59 148 70 219 116 34 22 99 64 146 94 46 29 84 57 84 63 0 5
+-5 6 -10 3 -6 -4 -26 -1 -45 5 -19 6 -67 12 -107 13 -40 1 -75 5 -78 9 -3 4
+-12 -1 -20 -11z m-697 -236 c-3 -9 -8 -14 -10 -11 -3 3 -2 9 2 15 9 16 15 13
+8 -4z"/>
+<path d="M2025 2320 c-17 -7 -15 -9 13 -9 17 -1 32 4 32 9 0 12 -17 12 -45 0z"/>
+<path d="M1910 2280 c-20 -12 -10 -19 14 -10 11 3 15 9 10 13 -6 3 -16 2 -24
+-3z"/>
+<path d="M1980 2274 c-29 -16 -8 -19 22 -3 16 8 23 8 30 -2 8 -11 9 -11 5 1
+-5 20 -26 21 -57 4z"/>
+<path d="M2065 2280 c-3 -5 1 -10 9 -10 9 0 16 5 16 10 0 6 -4 10 -9 10 -6 0
+-13 -4 -16 -10z"/>
+<path d="M1806 2271 c-12 -5 -15 -10 -9 -14 6 -4 16 0 23 8 14 17 13 17 -14 6z"/>
+<path d="M1340 2245 c-14 -8 -37 -14 -51 -15 -14 0 -34 -9 -44 -20 -18 -20
+-18 -21 -1 -38 14 -14 16 -14 11 -1 -7 19 20 44 57 53 14 3 34 9 44 13 12 4
+15 3 10 -5 -4 -7 -3 -12 3 -12 6 0 15 9 21 20 9 17 8 20 -7 20 -10 -1 -29 -7
+-43 -15z"/>
+<path d="M1190 2209 c0 -5 5 -7 10 -4 6 3 10 8 10 11 0 2 -4 4 -10 4 -5 0 -10
+-5 -10 -11z"/>
+<path d="M1140 2199 c0 -5 5 -7 10 -4 6 3 10 8 10 11 0 2 -4 4 -10 4 -5 0 -10
+-5 -10 -11z"/>
+<path d="M1330 2201 c0 -5 5 -13 10 -16 6 -3 10 -2 10 4 0 5 -4 13 -10 16 -5
+3 -10 2 -10 -4z"/>
+<path d="M1786 2184 c-11 -8 -16 -14 -10 -14 13 0 39 18 34 24 -3 2 -14 -2
+-24 -10z"/>
+<path d="M1294 2168 c6 -37 -36 -64 -48 -31 -3 8 -10 11 -16 8 -5 -3 -10 -1
+-10 6 0 7 -3 9 -6 6 -4 -4 -1 -13 5 -21 7 -8 11 -19 8 -23 -3 -4 16 -8 41 -8
+34 0 46 -4 44 -13 -1 -8 2 -11 8 -7 6 3 8 11 4 16 -3 6 2 17 12 25 18 14 18
+14 -3 5 -29 -15 -32 -14 -26 8 3 11 0 28 -6 38 -10 15 -10 14 -7 -9z"/>
+<path d="M2355 2150 c-3 -5 -3 -10 2 -10 4 -1 -3 -7 -16 -14 -14 -8 -31 -12
+-38 -9 -8 3 -13 0 -11 -8 2 -7 -9 -15 -27 -19 -25 -5 -27 -7 -11 -13 11 -5 25
+-2 35 6 26 22 87 47 115 47 14 0 26 4 26 10 0 6 -15 8 -36 4 -25 -4 -34 -2
+-29 5 3 6 4 11 1 11 -3 0 -8 -4 -11 -10z"/>
+<path d="M2135 2140 c-3 -5 -1 -10 4 -10 6 0 11 5 11 10 0 6 -2 10 -4 10 -3 0
+-8 -4 -11 -10z"/>
+<path d="M1676 2107 c-11 -8 -17 -18 -15 -23 2 -5 14 1 26 14 24 24 17 30 -11
+9z"/>
+<path d="M2025 2109 c-5 -7 -3 -10 6 -7 8 3 22 1 32 -4 11 -5 17 -5 17 2 0 5
+-4 10 -9 10 -5 0 -16 3 -24 6 -8 3 -18 0 -22 -7z"/>
+<path d="M2250 2109 c0 -5 5 -7 10 -4 6 3 10 8 10 11 0 2 -4 4 -10 4 -5 0 -10
+-5 -10 -11z"/>
+<path d="M2200 2099 c0 -5 -5 -7 -12 -3 -6 4 -8 3 -4 -4 3 -6 2 -13 -4 -17 -5
+-3 -10 -2 -10 3 0 6 -9 8 -20 5 -11 -3 -20 -9 -20 -14 0 -5 -7 -5 -17 -2 -10
+4 -14 2 -9 -5 9 -15 -13 -27 -27 -13 -13 13 -41 15 -33 3 11 -19 -15 -37 -55
+-37 -29 0 -44 -5 -46 -15 -4 -13 -3 -13 6 0 9 13 11 13 11 1 0 -12 3 -12 12
+-3 14 14 42 16 33 2 -7 -11 23 -3 41 11 6 5 15 5 19 1 5 -4 5 2 1 12 -6 16 -4
+17 10 6 13 -12 17 -11 24 0 5 8 12 11 16 7 4 -4 17 -1 28 6 12 7 35 12 52 12
+30 -1 31 0 22 27 -10 29 -18 36 -18 17z"/>
+<path d="M1967 2093 c-12 -12 -7 -22 8 -17 8 4 15 10 15 15 0 11 -14 12 -23 2z"/>
+<path d="M1367 2084 c-4 -4 -7 -17 -7 -28 1 -19 1 -20 11 -3 11 19 8 43 -4 31z"/>
+<path d="M1198 2073 c7 -3 16 -2 19 1 4 3 -2 6 -13 5 -11 0 -14 -3 -6 -6z"/>
+<path d="M1326 2065 c-3 -8 -1 -15 4 -15 13 0 22 18 11 24 -5 3 -11 -1 -15 -9z"/>
+<path d="M2000 2069 c0 -5 5 -7 10 -4 6 3 10 8 10 11 0 2 -4 4 -10 4 -5 0 -10
+-5 -10 -11z"/>
+<path d="M1065 2055 c-27 -8 -51 -19 -53 -25 -2 -5 -8 -8 -13 -4 -5 3 -14 2
+-21 -2 -8 -5 -6 -10 8 -15 12 -4 26 -1 36 8 9 9 37 18 61 20 28 3 44 10 44 19
+0 16 3 16 -62 -1z"/>
+<path d="M1155 2049 c-23 -9 -21 -10 20 -14 146 -13 178 -14 145 -5 -19 5 -57
+12 -85 16 -27 3 -52 8 -55 9 -3 1 -14 -1 -25 -6z"/>
+<path d="M1675 2050 c4 -6 1 -17 -5 -26 -11 -12 -9 -14 11 -10 13 2 32 -1 42
+-6 13 -6 17 -5 17 7 0 9 -8 18 -17 21 -10 3 -26 10 -37 15 -13 8 -16 7 -11 -1z"/>
+<path d="M1800 2046 c0 -2 7 -6 15 -10 8 -3 15 -1 15 4 0 6 -7 10 -15 10 -8 0
+-15 -2 -15 -4z"/>
+<path d="M903 2029 c3 -9 0 -22 -6 -29 -16 -16 43 10 61 27 11 11 11 13 0 13
+-8 0 -20 -6 -26 -12 -10 -10 -15 -10 -23 2 -9 13 -10 13 -6 -1z"/>
+<path d="M1860 2030 c0 -13 11 -13 30 0 12 8 11 10 -7 10 -13 0 -23 -4 -23
+-10z"/>
+<path d="M1780 2017 c0 -10 -6 -14 -14 -11 -7 3 -16 -1 -19 -8 -3 -9 2 -14 14
+-14 19 0 37 32 25 43 -3 4 -6 -1 -6 -10z"/>
+<path d="M1105 2010 c-3 -5 1 -10 9 -10 9 0 16 5 16 10 0 6 -4 10 -9 10 -6 0
+-13 -4 -16 -10z"/>
+<path d="M1160 2005 c0 -17 7 -21 40 -22 22 -1 41 1 44 5 2 4 -12 8 -32 9 -19
+1 -39 8 -43 15 -6 9 -9 7 -9 -7z"/>
+<path d="M1896 2008 c3 -5 10 -6 15 -3 13 9 11 12 -6 12 -8 0 -12 -4 -9 -9z"/>
+<path d="M1020 1990 c-11 -11 -22 -20 -25 -19 -3 0 -11 -2 -18 -4 -6 -3 -2 -6
+10 -6 12 -1 28 6 36 14 9 8 17 11 20 7 2 -4 2 -1 1 6 -3 8 5 11 24 7 22 -4 24
+-4 7 4 -29 14 -33 13 -55 -9z"/>
+<path d="M1558 1993 c11 -19 9 -24 -9 -33 -11 -7 -27 -9 -35 -6 -8 3 -13 2 -9
+-3 8 -14 -17 -19 -43 -9 -17 6 -23 5 -20 -4 9 -26 68 -20 117 11 26 17 50 31
+54 31 3 0 5 -12 4 -27 -2 -18 -11 -32 -26 -39 -39 -20 -41 -29 -6 -29 18 0 31
+3 28 8 -2 4 7 7 21 7 16 0 26 6 26 14 0 8 6 17 13 19 6 3 0 6 -15 6 -33 1 -43
+15 -22 32 14 11 18 11 28 -1 6 -8 22 -15 36 -16 14 -1 34 -4 45 -8 19 -8 19
+-7 -1 11 -12 10 -24 26 -27 36 -4 10 -12 15 -18 11 -8 -4 -7 -9 2 -15 11 -6
+10 -9 -3 -14 -9 -4 -27 0 -40 8 -13 8 -36 13 -53 11 -16 -1 -36 2 -44 9 -12
+10 -13 9 -3 -10z"/>
+<path d="M1501 1989 c-14 -5 -36 -9 -50 -8 -44 3 -71 -1 -71 -10 0 -6 12 -6
+29 -1 16 4 32 6 35 3 8 -9 96 7 96 18 0 11 -8 11 -39 -2z"/>
+<path d="M815 1980 c-3 -6 1 -7 9 -4 18 7 21 14 7 14 -6 0 -13 -4 -16 -10z"/>
+<path d="M866 1972 c-4 -10 -13 -19 -21 -20 -8 -1 -22 -3 -30 -4 -8 -1 -12 -4
+-10 -8 2 -4 18 -5 35 -2 18 2 30 0 30 -7 0 -6 -9 -11 -20 -11 -11 0 -20 -5
+-20 -11 0 -7 8 -9 23 -4 12 4 46 9 75 12 29 3 55 10 59 16 4 6 -7 7 -31 3 -24
+-5 -36 -3 -36 4 0 6 5 8 10 5 6 -3 10 -1 10 4 0 15 -11 13 -34 -4 -25 -19 -38
+-10 -30 21 7 28 -2 33 -10 6z"/>
+<path d="M1300 1980 c-12 -8 -9 -10 13 -10 15 0 27 5 27 10 0 13 -20 13 -40 0z"/>
+<path d="M1803 1980 c2 -8 10 -14 17 -12 7 1 20 -3 29 -10 9 -7 13 -8 9 -4 -4
+5 -2 16 5 24 10 13 9 14 -3 7 -20 -12 -43 -12 -53 0 -5 6 -7 4 -4 -5z"/>
+<path d="M1160 1948 c0 -4 4 -8 9 -8 6 0 12 4 15 8 3 5 -1 9 -9 9 -8 0 -15 -4
+-15 -9z"/>
+<path d="M988 1918 c-21 -21 -11 -24 15 -4 10 8 15 16 10 18 -4 3 -16 -3 -25
+-14z"/>
+<path d="M1080 1927 c0 -11 -50 -27 -125 -42 -27 -6 -135 -58 -135 -67 0 -10
+44 3 55 16 13 16 57 32 125 46 30 7 64 17 75 23 28 15 88 20 80 7 -4 -6 6 -10
+24 -10 16 0 33 5 36 10 4 7 -3 9 -22 5 -21 -5 -24 -4 -13 4 12 9 9 11 -15 12
+-16 1 -42 3 -57 5 -17 2 -28 -2 -28 -9z"/>
+<path d="M735 1910 c-26 -28 -15 -31 12 -3 12 13 19 23 14 23 -4 0 -16 -9 -26
+-20z"/>
+<path d="M1667 1894 c-28 -15 -36 -26 -14 -21 7 1 11 -7 10 -18 -1 -11 3 -23
+9 -26 21 -13 -4 -30 -34 -24 -21 5 -28 4 -24 -4 4 -6 12 -9 17 -6 5 4 9 1 9
+-4 0 -16 16 -13 34 4 8 8 21 15 28 15 9 1 8 4 -3 10 -17 10 -15 59 4 71 21 14
+-10 16 -36 3z"/>
+<path d="M1430 1885 c0 -8 2 -15 4 -15 2 0 6 7 10 15 3 8 1 15 -4 15 -6 0 -10
+-7 -10 -15z"/>
+<path d="M1485 1890 c-3 -5 3 -10 15 -10 12 0 18 5 15 10 -3 6 -10 10 -15 10
+-5 0 -12 -4 -15 -10z"/>
+<path d="M1255 1880 c3 -5 10 -10 16 -10 5 0 9 5 9 10 0 6 -7 10 -16 10 -8 0
+-12 -4 -9 -10z"/>
+<path d="M1720 1880 c-12 -8 -10 -10 8 -10 13 0 20 4 17 10 -7 12 -6 12 -25 0z"/>
+<path d="M685 1870 c-3 -5 -1 -10 4 -10 6 0 11 5 11 10 0 6 -2 10 -4 10 -3 0
+-8 -4 -11 -10z"/>
+<path d="M844 1864 c4 -11 1 -14 -12 -10 -13 4 -32 -7 -62 -34 -24 -22 -41
+-43 -38 -46 3 -3 25 13 48 36 22 22 46 38 51 34 13 -7 41 15 33 27 -9 15 -26
+10 -20 -7z"/>
+<path d="M1088 1866 c-26 -20 -22 -26 12 -16 19 6 32 5 36 -2 4 -7 2 -8 -4 -4
+-7 4 -12 2 -12 -3 0 -16 26 -13 40 4 15 19 13 21 -25 29 -18 3 -37 0 -47 -8z"/>
+<path d="M1525 1870 c-3 -5 1 -10 10 -10 8 0 24 -6 35 -12 15 -10 22 -10 32 0
+9 9 8 12 -5 12 -25 0 -30 1 -49 11 -10 6 -19 5 -23 -1z"/>
+<path d="M1315 1849 c-17 -17 -17 -19 -2 -14 20 8 23 -5 5 -23 -21 -21 8 -14
+33 8 13 11 20 20 14 19 -24 -3 -34 2 -29 16 8 20 3 18 -21 -6z"/>
+<path d="M1030 1851 c0 -8 -8 -11 -20 -8 -11 3 -20 1 -20 -4 0 -5 -3 -8 -7 -7
+-5 2 -19 -5 -33 -15 -30 -21 -22 -22 15 -3 15 8 33 12 40 10 14 -6 41 23 31
+33 -3 3 -6 1 -6 -6z"/>
+<path d="M1477 1842 c5 -12 1 -14 -20 -8 -14 3 -29 2 -32 -4 -3 -5 -14 -10
+-24 -10 -10 0 -25 -8 -32 -17 -13 -16 -12 -17 3 -4 10 7 38 14 62 16 24 2 49
+6 55 9 16 10 14 1 -9 -36 -11 -18 -20 -29 -20 -24 0 5 -6 4 -12 -1 -7 -6 -23
+-13 -35 -16 -18 -4 -23 -1 -23 15 0 10 -5 16 -10 13 -6 -4 -8 -10 -5 -15 3 -4
+-6 -10 -18 -14 -13 -3 -36 -17 -52 -30 -16 -14 -31 -24 -34 -24 -10 2 -81 -32
+-81 -38 0 -3 12 -3 26 0 17 5 23 3 19 -4 -3 -5 -2 -10 4 -10 6 0 15 -15 20
+-32 9 -30 10 -31 16 -11 7 22 31 37 45 28 4 -3 10 2 14 10 3 8 13 15 23 15 14
+0 15 2 4 9 -11 7 -6 13 18 26 22 11 31 21 27 31 -3 9 -2 12 5 9 5 -4 27 6 47
+22 20 15 38 26 39 23 2 -3 10 6 20 19 12 18 13 26 5 29 -7 2 -10 7 -8 11 2 3
+-6 11 -19 17 -19 10 -22 9 -18 -4z m-87 -111 c0 -13 -82 -77 -107 -83 -13 -4
+-23 -5 -23 -4 0 12 61 67 69 62 5 -4 15 3 21 14 11 20 40 28 40 11z"/>
+<path d="M930 1835 c-14 -8 -20 -14 -14 -15 5 0 19 7 30 15 24 18 16 19 -16 0z"/>
+<path d="M1220 1834 c0 -8 5 -12 10 -9 6 3 10 10 10 16 0 5 -4 9 -10 9 -5 0
+-10 -7 -10 -16z"/>
+<path d="M676 1809 c-21 -11 -41 -29 -43 -40 -3 -10 -9 -17 -12 -14 -4 2 -8
+-3 -8 -12 0 -10 12 -2 32 21 17 20 35 36 41 36 6 0 19 7 30 15 28 21 5 18 -40
+-6z"/>
+<path d="M1085 1817 c-22 -13 -31 -37 -15 -37 6 0 10 5 10 11 0 7 8 18 18 25
+21 17 14 17 -13 1z"/>
+<path d="M1233 1818 c-13 -6 -23 -15 -23 -20 0 -4 -4 -8 -10 -8 -5 0 -7 7 -4
+15 5 13 -13 15 -76 5 -3 0 1 -4 8 -9 12 -7 12 -12 1 -30 -8 -11 -18 -20 -24
+-19 -5 1 -28 -8 -50 -20 -26 -15 -31 -20 -15 -16 14 3 29 10 35 15 5 5 17 9
+27 9 9 0 21 6 25 14 9 16 43 24 58 14 6 -3 28 9 50 28 40 34 39 42 -2 22z"/>
+<path d="M1285 1810 c3 -5 8 -10 11 -10 2 0 4 5 4 10 0 6 -5 10 -11 10 -5 0
+-7 -4 -4 -10z"/>
+<path d="M955 1774 c-71 -40 -62 -44 21 -9 32 13 53 24 46 25 -7 0 -10 5 -7
+10 8 12 11 14 -60 -26z"/>
+<path d="M804 1785 c-15 -11 -16 -14 -3 -15 8 0 24 7 35 15 15 11 16 14 3 15
+-8 0 -24 -7 -35 -15z"/>
+<path d="M1028 1779 c-14 -15 -15 -19 -4 -19 8 0 16 -6 19 -12 2 -7 4 2 5 20
+0 17 0 32 -1 31 -1 0 -10 -9 -19 -20z"/>
+<path d="M885 1780 c3 -6 -4 -14 -17 -19 -26 -10 -74 -56 -90 -86 -7 -12 5 -5
+30 18 23 20 52 37 65 38 13 0 16 3 8 6 -11 4 -9 10 9 23 20 15 20 18 6 23 -10
+4 -15 3 -11 -3z"/>
+<path d="M1270 1775 c-7 -8 -18 -15 -24 -14 -24 3 -36 -2 -61 -25 -18 -17 -22
+-26 -13 -29 7 -3 0 -6 -17 -6 -16 -1 -41 -4 -54 -8 -16 -4 -22 -3 -17 5 4 8
+-3 8 -26 1 -35 -10 -89 -59 -65 -59 8 0 22 10 31 23 10 14 14 16 10 5 -7 -20
+20 -26 31 -8 3 6 11 10 16 10 6 0 7 -5 3 -12 -5 -8 2 -9 26 -5 27 6 30 5 21
+-7 -6 -7 -39 -19 -74 -25 -98 -19 -136 -38 -108 -55 5 -3 20 3 34 14 26 21 57
+27 57 11 0 -10 -61 -41 -80 -41 -22 0 -80 -41 -80 -56 0 -12 4 -12 20 -2 11 7
+20 18 20 25 0 14 2 15 40 19 14 1 36 6 50 10 24 7 24 7 8 -13 -10 -11 -18 -22
+-18 -26 0 -3 8 -4 18 0 9 3 0 -11 -20 -33 -21 -22 -38 -45 -38 -52 0 -6 -9
+-16 -20 -22 -11 -6 -18 -15 -15 -21 4 -5 -1 -9 -9 -9 -8 0 -17 4 -21 10 -3 5
+-12 7 -20 3 -24 -9 -17 10 20 49 19 21 49 42 67 47 33 9 33 9 5 10 -19 1 -26
+5 -21 13 5 7 3 8 -5 4 -7 -5 -10 -10 -8 -13 3 -2 -13 -22 -36 -43 -22 -22 -41
+-50 -42 -62 -1 -13 -7 -22 -13 -21 -5 1 -15 -4 -21 -11 -10 -12 -6 -13 26 -5
+56 13 73 11 67 -6 -4 -8 1 -17 10 -21 29 -11 13 -89 -32 -151 -16 -23 -19 -31
+-8 -27 14 5 53 78 70 127 4 11 11 15 18 11 9 -5 8 -2 -1 10 -8 9 -10 16 -5 14
+5 -1 21 10 37 25 15 16 32 25 39 21 7 -4 8 -3 4 4 -4 7 -3 12 2 12 10 0 35 50
+28 57 -2 2 -7 -5 -11 -16 -3 -12 -19 -28 -34 -35 -15 -8 -33 -22 -40 -30 -19
+-23 -34 -20 -26 5 5 15 4 19 -4 15 -25 -16 -9 27 25 64 37 41 70 51 80 25 4
+-8 15 -15 26 -15 10 0 16 5 13 10 -4 6 -11 7 -17 4 -7 -4 -8 -2 -4 5 4 6 10 9
+14 7 4 -2 23 4 42 15 19 10 47 24 63 31 15 7 27 16 27 20 0 8 -66 -19 -90 -38
+-35 -26 -44 -28 -35 -8 4 10 7 27 7 37 0 9 3 15 9 12 5 -4 12 1 15 9 3 9 10
+16 16 16 5 0 6 -4 3 -10 -8 -13 -1 -13 40 4 18 8 39 24 45 36 l11 21 -41 -21
+c-57 -29 -73 -20 -25 13 24 16 33 27 23 27 -26 0 -68 -22 -68 -35 0 -7 -20
+-29 -45 -49 -25 -21 -45 -45 -46 -54 0 -13 -3 -11 -9 5 -10 24 1 76 21 99 7 8
+21 11 35 8 13 -3 24 -2 24 2 0 15 57 74 64 67 3 -3 6 0 6 8 0 19 23 69 32 69
+3 0 4 -9 1 -20 -3 -11 0 -20 6 -20 6 0 11 4 11 10 0 5 7 7 15 4 8 -4 15 -1 15
+5 0 6 6 11 13 11 6 0 21 8 32 16 20 15 19 16 -5 12 -16 -2 -24 2 -22 10 3 16
+-3 15 -18 -3z m-200 -89 c0 -3 -4 -8 -10 -11 -5 -3 -10 -1 -10 4 0 6 5 11 10
+11 6 0 10 -2 10 -4z m30 -186 c-6 -11 -18 -20 -27 -20 -14 0 -14 2 2 20 10 11
+22 20 27 20 5 0 4 -9 -2 -20z"/>
+<path d="M1542 1778 c-16 -16 -15 -25 3 -25 16 0 28 24 16 31 -4 3 -13 0 -19
+-6z"/>
+<path d="M683 1768 c-10 -18 -13 -39 -3 -33 8 5 21 45 15 45 -2 0 -7 -6 -12
+-12z"/>
+<path d="M950 1740 c-8 -5 -12 -11 -9 -14 2 -3 11 -1 19 4 8 5 12 11 9 14 -2
+3 -11 1 -19 -4z"/>
+<path d="M749 1713 l-24 -28 28 24 c25 23 32 31 24 31 -2 0 -14 -12 -28 -27z"/>
+<path d="M1656 1725 c-4 -13 -2 -14 14 -5 23 13 26 20 6 20 -8 0 -16 -7 -20
+-15z"/>
+<path d="M975 1715 c-16 -7 -34 -11 -39 -7 -5 3 -6 0 -2 -6 4 -6 -2 -17 -14
+-24 -11 -7 -20 -17 -20 -22 0 -5 11 1 25 14 14 13 28 20 32 15 5 -4 2 -10 -4
+-12 -7 -3 -13 -10 -13 -16 0 -6 10 -1 23 11 13 12 30 22 38 22 12 0 12 2 0 9
+-11 7 -11 9 0 13 8 3 12 7 9 10 -3 3 -18 -1 -35 -7z"/>
+<path d="M1485 1699 c-4 -17 -9 -28 -12 -25 -3 3 -17 -4 -31 -14 -27 -22 -54
+-28 -34 -8 7 7 12 16 12 21 0 5 -29 -20 -64 -56 -45 -45 -62 -58 -60 -43 2 12
+-5 2 -16 -21 -12 -26 -31 -46 -50 -55 -17 -7 -30 -18 -30 -23 0 -11 -69 -52
+-82 -48 -4 2 -5 -3 -2 -10 3 -8 0 -25 -5 -40 -7 -18 -7 -27 2 -30 7 -2 8 -8 4
+-13 -13 -13 -27 18 -21 46 5 22 3 22 -17 -8 -13 -19 -27 -31 -35 -28 -8 3 -14
+-1 -14 -9 0 -7 -6 -20 -13 -27 -27 -27 -67 -85 -67 -96 0 -7 5 -12 10 -12 6 0
+10 4 10 10 0 5 16 32 36 60 29 40 42 50 65 50 40 0 37 -23 -6 -49 -20 -11 -38
+-29 -42 -38 -3 -10 -15 -30 -25 -45 -16 -23 -17 -28 -4 -28 8 0 16 -8 19 -18
+2 -9 4 0 3 21 0 39 17 61 41 52 7 -2 10 2 7 9 -5 12 63 92 71 84 4 -4 12 -40
+14 -62 1 -4 7 -6 15 -3 24 9 39 -19 32 -58 -4 -19 -10 -35 -15 -35 -4 0 -8 -6
+-9 -12 -1 -7 -4 -26 -7 -43 -5 -27 -3 -26 14 10 11 22 20 48 20 59 1 14 4 16
+15 7 19 -16 5 -82 -29 -131 -16 -23 -32 -43 -37 -46 -4 -3 -8 -14 -8 -25 0
+-29 22 -18 31 15 8 29 36 66 50 66 15 0 15 -35 0 -53 -18 -22 -22 -118 -4
+-124 10 -4 10 37 -1 72 -2 6 1 19 6 30 8 18 8 18 4 -2 -2 -13 0 -23 6 -23 14
+0 31 20 61 71 17 29 34 46 45 45 18 -1 19 2 21 64 1 28 5 40 16 40 15 0 19 15
+16 57 -1 11 2 24 7 27 5 3 7 17 5 31 -3 13 -9 22 -14 20 -4 -3 -6 -12 -3 -20
+3 -8 -1 -21 -9 -29 -8 -8 -12 -25 -10 -39 3 -14 -2 -29 -12 -37 -15 -12 -16
+-8 -14 53 1 36 6 64 11 61 5 -3 6 6 2 20 -4 16 -2 26 4 26 6 0 18 15 27 33 12
+25 13 43 6 73 l-9 39 -1 -40 c-2 -56 -11 -85 -28 -85 -8 0 -12 -4 -9 -9 3 -5
+-12 -24 -33 -42 -22 -17 -42 -40 -44 -51 -3 -10 -11 -18 -17 -18 -8 0 -10 7
+-5 23 4 12 8 36 9 53 1 17 10 43 20 59 18 27 20 28 27 10 6 -17 8 -15 8 8 1
+16 7 43 15 60 45 106 49 131 6 42 -16 -33 -30 -53 -30 -45 0 8 -12 -9 -27 -38
+-15 -29 -30 -52 -34 -52 -5 0 -6 7 -3 15 4 8 2 15 -4 15 -11 0 -22 -23 -22
+-46 0 -8 3 -13 8 -13 20 3 32 -2 26 -12 -3 -6 -8 -32 -10 -58 -2 -37 0 -48 11
+-48 8 0 15 5 15 11 0 15 48 66 61 66 7 0 9 -16 6 -42 -3 -22 -1 -55 4 -72 7
+-24 6 -34 -7 -43 -10 -7 -11 -13 -5 -18 6 -3 11 -1 11 4 0 6 4 11 8 11 5 0 9
+-7 9 -15 0 -8 -6 -15 -13 -15 -8 0 -21 -14 -30 -32 -9 -18 -23 -38 -30 -46 -8
+-7 -14 -20 -14 -28 0 -8 -4 -14 -10 -14 -12 0 -12 2 -1 33 8 19 6 27 -5 31 -8
+3 -14 10 -14 16 0 6 5 8 11 4 9 -5 10 1 5 20 -4 15 -2 26 4 26 6 0 6 9 -1 26
+-5 15 -7 36 -4 48 5 15 4 17 -3 7 -10 -14 -17 -2 -27 51 -3 12 -9 24 -15 26
+-5 2 -10 13 -10 25 -1 22 -1 22 -17 2 -15 -19 -15 -18 -9 14 3 19 17 49 31 67
+27 36 30 44 15 44 -5 0 -10 -7 -10 -15 0 -8 -6 -15 -14 -15 -8 0 -16 -10 -18
+-22 -5 -36 -33 -28 -36 11 -2 21 0 31 7 26 6 -3 11 -1 11 4 0 6 6 11 13 11 7
+0 32 16 55 36 23 19 42 32 42 29 0 -4 6 -2 14 4 11 10 15 8 19 -6 3 -10 5 -3
+6 15 2 61 111 137 111 77 0 -7 -4 -15 -8 -17 -9 -4 -52 -63 -52 -72 0 -19 23
+-1 31 24 6 16 15 28 19 25 5 -3 15 14 22 37 16 47 36 55 54 21 6 -13 14 -20
+17 -16 4 3 7 -3 7 -15 0 -14 -5 -20 -13 -16 -14 5 -45 -69 -39 -93 2 -7 -2
+-13 -8 -13 -5 0 -10 6 -11 13 -4 58 -18 92 -20 46 0 -13 -2 -34 -3 -46 -4 -31
+11 -53 23 -34 5 7 14 10 20 7 7 -5 11 2 11 18 0 31 18 73 45 102 11 12 26 30
+34 39 8 10 23 15 37 12 17 -3 28 3 41 22 14 22 14 24 1 13 -9 -7 -25 -15 -37
+-17 -18 -3 -20 -1 -11 15 19 35 10 34 -25 -4 -19 -21 -39 -35 -46 -31 -7 5 2
+20 25 44 26 27 33 40 26 51 -7 10 -10 11 -10 3 0 -7 -11 -13 -25 -13 -27 0
+-34 17 -10 26 8 4 12 10 9 15 -10 17 -22 9 -29 -22z m19 -59 c-15 -16 -31 -27
+-36 -24 -12 8 31 54 49 54 8 0 3 -12 -13 -30z m-324 -374 c0 -3 -4 -8 -10 -11
+-5 -3 -10 -1 -10 4 0 6 5 11 10 11 6 0 10 -2 10 -4z"/>
+<path d="M906 1707 c3 -10 9 -15 12 -12 3 3 0 11 -7 18 -10 9 -11 8 -5 -6z"/>
+<path d="M1438 1713 c-20 -5 -24 -23 -5 -23 6 0 21 7 31 15 20 15 11 18 -26 8z"/>
+<path d="M620 1689 c-22 -18 -22 -19 -3 -10 12 6 25 16 28 21 9 15 3 12 -25
+-11z"/>
+<path d="M833 1685 l-28 -26 38 22 c37 21 45 29 28 29 -6 0 -23 -11 -38 -25z"/>
+<path d="M712 1645 c-20 -19 -32 -35 -26 -35 5 0 25 16 44 35 44 45 31 45 -18
+0z"/>
+<path d="M870 1670 c-9 -6 -10 -10 -3 -10 6 0 15 5 18 10 8 12 4 12 -15 0z"/>
+<path d="M1645 1640 c-3 -5 -1 -10 4 -10 6 0 11 5 11 10 0 6 -2 10 -4 10 -3 0
+-8 -4 -11 -10z"/>
+<path d="M950 1626 c0 -8 -6 -17 -12 -19 -10 -4 -10 -6 -1 -6 7 -1 17 8 23 19
+7 14 7 20 0 20 -5 0 -10 -6 -10 -14z"/>
+<path d="M719 1613 c-13 -16 -12 -17 4 -4 9 7 17 15 17 17 0 8 -8 3 -21 -13z"/>
+<path d="M774 1621 c3 -5 -12 -25 -34 -45 -22 -20 -40 -38 -40 -41 0 -13 20
+-2 53 30 36 35 48 65 26 65 -5 0 -8 -4 -5 -9z"/>
+<path d="M842 1606 c-15 -17 -19 -25 -10 -28 8 -3 2 -16 -19 -36 -17 -18 -28
+-32 -23 -32 5 0 12 5 15 10 4 6 10 8 15 5 11 -7 23 13 26 43 2 13 11 33 20 43
+25 28 3 23 -24 -5z"/>
+<path d="M555 1609 c-11 -17 1 -21 15 -4 8 9 8 15 2 15 -6 0 -14 -5 -17 -11z"/>
+<path d="M900 1610 c0 -5 5 -10 11 -10 5 0 7 5 4 10 -3 6 -8 10 -11 10 -2 0
+-4 -4 -4 -10z"/>
+<path d="M1627 1579 c-21 -22 -37 -47 -37 -56 0 -8 -9 -26 -20 -40 -15 -19
+-17 -30 -10 -44 10 -17 5 -60 -8 -84 -10 -16 -11 -55 -2 -55 4 0 7 10 6 23 -2
+12 3 28 10 35 10 9 14 -4 18 -66 2 -42 8 -96 11 -118 4 -26 3 -44 -4 -48 -6
+-4 -11 -12 -11 -19 0 -6 11 0 25 15 25 27 33 44 15 33 -5 -3 -7 9 -5 30 4 26
+1 35 -10 35 -8 0 -15 8 -14 18 0 10 3 12 6 5 10 -26 25 -13 20 17 -4 16 0 48
+8 71 20 56 19 60 -6 20 -25 -42 -37 -34 -14 11 22 42 36 98 24 98 -8 0 -13
+-22 -10 -42 0 -5 -3 -8 -9 -8 -5 0 -10 -7 -10 -15 0 -8 -4 -15 -10 -15 -13 0
+-13 45 1 93 7 27 15 37 25 33 17 -6 18 -1 4 24 -7 13 -7 21 2 26 7 4 8 3 4 -4
+-4 -7 -5 -12 -2 -12 3 0 15 18 26 40 11 22 19 40 17 40 -2 0 -20 -18 -40 -41z"/>
+<path d="M1696 1594 c-11 -7 -16 -17 -13 -21 4 -4 15 1 24 10 22 21 14 30 -11
+11z"/>
+<path d="M1442 1580 c-9 -14 -9 -20 -1 -20 8 0 7 -6 -2 -17 -11 -15 -11 -16 1
+-6 7 7 14 24 16 38 3 30 2 31 -14 5z"/>
+<path d="M652 1561 c-17 -17 -32 -33 -32 -37 0 -5 17 8 37 27 21 18 40 35 42
+37 2 1 0 2 -5 2 -5 0 -24 -13 -42 -29z"/>
+<path d="M1765 1581 c-3 -5 -2 -12 3 -15 5 -3 9 1 9 9 0 17 -3 19 -12 6z"/>
+<path d="M488 1573 c7 -3 16 -2 19 1 4 3 -2 6 -13 5 -11 0 -14 -3 -6 -6z"/>
+<path d="M1060 1565 c-7 -9 -8 -15 -2 -15 5 0 12 7 16 15 3 8 4 15 2 15 -2 0
+-9 -7 -16 -15z"/>
+<path d="M1722 1568 c-18 -18 -15 -38 5 -31 11 4 13 8 5 11 -10 3 -10 7 -1 18
+14 17 8 19 -9 2z"/>
+<path d="M784 1561 c7 -11 -28 -43 -38 -34 -4 4 -4 0 0 -10 3 -9 2 -17 -3 -17
+-5 0 -18 -8 -29 -18 -10 -10 -27 -21 -36 -25 -18 -6 -25 -27 -10 -27 12 0 132
+118 132 130 0 5 -5 10 -11 10 -5 0 -8 -4 -5 -9z"/>
+<path d="M528 1553 c7 -3 16 -2 19 1 4 3 -2 6 -13 5 -11 0 -14 -3 -6 -6z"/>
+<path d="M1544 1524 c3 -9 6 -18 6 -20 0 -3 4 -3 10 1 11 7 2 35 -12 35 -6 0
+-7 -7 -4 -16z"/>
+<path d="M1650 1510 c-7 -14 -7 -20 0 -20 5 0 10 6 10 14 0 8 6 17 13 19 9 4
+9 6 0 6 -7 1 -17 -8 -23 -19z"/>
+<path d="M820 1490 c-14 -10 -22 -21 -19 -24 3 -3 16 5 29 19 28 30 24 32 -10
+5z"/>
+<path d="M1509 1503 c-2 -29 -11 -58 -20 -70 -9 -10 -8 -13 4 -13 13 0 14 -6
+6 -36 -6 -19 -7 -48 -4 -64 3 -15 2 -31 -4 -34 -6 -4 -7 -14 -4 -22 5 -13 1
+-15 -18 -9 -20 7 -22 5 -13 -6 7 -8 14 -33 18 -56 4 -34 3 -41 -9 -36 -17 6
+-20 -14 -5 -37 8 -12 10 -12 10 5 2 44 21 -30 25 -93 1 -35 6 -66 9 -69 3 -4
+6 0 6 8 1 8 7 -2 14 -21 8 -19 20 -49 27 -66 11 -28 9 -39 -13 -101 -21 -56
+-23 -70 -12 -70 8 0 13 6 10 13 -3 8 5 20 17 29 20 14 21 15 2 16 -19 0 -19 1
+-2 8 10 4 18 10 18 14 -1 4 -1 19 -1 33 0 22 2 25 15 14 8 -7 15 -18 15 -24 0
+-6 9 -17 21 -24 19 -12 20 -12 13 10 -4 13 -8 42 -9 66 -2 24 -6 46 -9 49 -4
+4 -6 -6 -5 -23 4 -74 -17 -69 -27 7 -4 27 -10 52 -14 54 -5 3 -6 -4 -3 -15 10
+-37 -8 -20 -29 28 -34 76 -62 282 -39 282 6 0 11 10 11 23 0 13 3 27 6 30 11
+10 13 67 3 67 -11 0 -6 45 10 83 9 23 8 31 -4 43 -8 9 -15 12 -16 7z"/>
+<path d="M1665 1471 c-12 -40 -8 -102 9 -119 16 -16 16 -15 7 11 -8 21 -8 27
+2 26 23 -3 40 1 34 8 -4 3 -2 12 4 20 6 7 8 13 3 13 -5 0 -2 5 6 10 11 7 11
+10 2 10 -7 0 -18 -13 -23 -30 -14 -38 -30 -29 -25 14 5 41 -9 69 -19 37z"/>
+<path d="M532 1467 c-17 -20 -12 -40 6 -28 8 5 12 16 10 26 -3 17 -4 17 -16 2z"/>
+<path d="M638 1473 c6 -2 18 -2 25 0 6 3 1 5 -13 5 -14 0 -19 -2 -12 -5z"/>
+<path d="M761 1466 c-13 -7 -19 -16 -14 -19 6 -4 18 2 28 13 21 23 19 24 -14
+6z"/>
+<path d="M482 1450 c-29 -28 -28 -34 3 -14 14 9 25 20 25 25 0 13 -4 11 -28
+-11z"/>
+<path d="M588 1449 l-23 -20 25 13 c14 6 31 11 38 10 17 -4 15 5 -3 11 -7 3
+-24 -3 -37 -14z"/>
+<path d="M701 1430 c-13 -11 -18 -20 -13 -20 6 0 14 5 17 10 4 6 10 8 14 6 4
+-3 8 1 8 9 0 8 -1 15 -1 15 -1 -1 -12 -10 -25 -20z"/>
+<path d="M815 1440 c-3 -5 3 -10 14 -10 12 0 21 5 21 10 0 6 -6 10 -14 10 -8
+0 -18 -4 -21 -10z"/>
+<path d="M913 1428 c-4 -7 -8 -20 -10 -28 -1 -10 3 -9 13 4 14 19 18 36 10 36
+-3 0 -8 -6 -13 -12z"/>
+<path d="M1026 1423 c-6 -14 -5 -15 5 -6 7 7 10 15 7 18 -3 3 -9 -2 -12 -12z"/>
+<path d="M1335 1420 c-5 -14 -2 -28 8 -37 13 -13 14 -11 11 18 -5 41 -10 46
+-19 19z"/>
+<path d="M778 1423 c7 -3 16 -2 19 1 4 3 -2 6 -13 5 -11 0 -14 -3 -6 -6z"/>
+<path d="M545 1400 c-3 -10 -19 -30 -36 -44 -16 -14 -28 -29 -27 -33 2 -5 -7
+-21 -18 -36 -16 -19 -27 -25 -40 -21 -17 6 -17 5 0 -8 19 -15 19 -16 -10 -48
+-16 -17 -40 -36 -54 -42 -22 -9 -23 -11 -7 -17 16 -6 15 -9 -9 -31 -15 -14
+-24 -20 -21 -13 4 6 3 23 -3 38 -8 20 -7 27 4 31 16 6 40 64 27 64 -4 0 -13
+-11 -19 -24 -6 -13 -18 -23 -28 -23 -15 2 -17 -6 -15 -49 1 -33 -2 -55 -10
+-60 -9 -5 -7 -9 7 -15 15 -6 35 10 102 79 45 47 81 90 79 96 -6 15 50 84 74
+91 10 4 17 11 13 16 -4 6 -11 6 -20 -2 -8 -7 -14 -7 -14 -1 0 5 7 15 16 22 21
+18 37 50 25 50 -5 0 -12 -9 -16 -20z"/>
+<path d="M609 1400 c-21 -17 -21 -19 -4 -13 11 3 29 12 40 20 16 10 16 13 3
+13 -9 0 -26 -9 -39 -20z"/>
+<path d="M785 1400 c-3 -6 1 -7 9 -4 18 7 21 14 7 14 -6 0 -13 -4 -16 -10z"/>
+<path d="M1429 1403 c0 -5 0 -35 1 -68 1 -33 -4 -73 -10 -89 -11 -30 0 -56 24
+-56 8 0 8 2 0 8 -6 4 -10 18 -8 32 1 14 3 31 3 39 1 7 7 11 14 8 10 -4 12 7 9
+46 -2 29 -9 55 -16 59 -8 6 -7 8 2 8 6 0 12 5 12 10 0 11 -30 14 -31 3z"/>
+<path d="M469 1387 c5 -5 17 -5 28 2 16 9 15 10 -9 9 -16 -2 -24 -6 -19 -11z"/>
+<path d="M620 1379 c-26 -14 -30 -19 -15 -19 11 0 34 9 50 20 38 25 12 24 -35
+-1z"/>
+<path d="M710 1375 c-30 -17 -43 -19 -35 -5 3 6 1 10 -5 10 -7 0 -10 -6 -7
+-12 5 -14 56 -12 71 3 17 15 2 18 -24 4z"/>
+<path d="M733 1347 c-27 -29 -27 -29 -4 -17 14 7 33 20 43 30 14 13 15 17 3
+17 -8 0 -27 -14 -42 -30z"/>
+<path d="M1402 1345 c0 -16 2 -22 5 -12 2 9 2 23 0 30 -3 6 -5 -1 -5 -18z"/>
+<path d="M1300 1340 c0 -11 4 -20 8 -20 4 0 8 9 9 20 1 11 -2 20 -8 20 -5 0
+-9 -9 -9 -20z"/>
+<path d="M1270 1335 c0 -8 2 -15 4 -15 2 0 6 7 10 15 3 8 1 15 -4 15 -6 0 -10
+-7 -10 -15z"/>
+<path d="M574 1314 c-5 -21 -11 -25 -30 -21 -19 3 -22 2 -13 -9 9 -11 7 -15
+-5 -20 -9 -3 -14 -10 -11 -15 3 -4 -7 -15 -22 -24 -15 -9 -19 -13 -8 -10 11 4
+28 10 37 12 10 3 15 10 11 16 -4 6 0 8 10 4 10 -3 17 -2 17 3 0 5 10 19 23 31
+12 12 15 18 7 14 -12 -6 -13 -5 -2 6 14 16 16 39 2 39 -5 0 -13 -12 -16 -26z"/>
+<path d="M642 1310 c-63 -46 -53 -49 27 -9 20 10 30 18 23 19 -7 0 -10 5 -7
+10 10 16 0 12 -43 -20z"/>
+<path d="M410 1314 c0 -8 5 -12 10 -9 6 4 8 11 5 16 -9 14 -15 11 -15 -7z"/>
+<path d="M803 1313 c-7 -2 -13 -11 -13 -19 0 -8 -7 -14 -16 -14 -10 0 -14 -6
+-11 -14 8 -20 -16 -26 -29 -8 -10 14 -12 13 -18 -4 -3 -11 -20 -28 -37 -38
+-17 -10 -28 -20 -25 -23 3 -3 16 1 28 9 13 8 32 18 42 21 15 6 17 5 8 -6 -7
+-8 -9 -16 -6 -20 3 -3 -7 -13 -23 -23 -15 -10 -30 -19 -32 -20 -1 -2 0 -8 4
+-14 9 -14 41 19 81 82 16 27 35 48 42 48 7 0 10 5 7 10 -4 6 -1 9 5 8 7 -2 14
+5 15 15 3 17 -1 19 -22 10z"/>
+<path d="M900 1309 c0 -19 -52 -129 -61 -129 -5 0 -9 -4 -9 -10 0 -20 28 3 49
+41 29 51 42 97 30 104 -5 4 -9 1 -9 -6z"/>
+<path d="M1663 1285 c-7 -21 -8 -46 -3 -63 l8 -27 2 30 c1 17 4 45 6 63 5 42
+0 41 -13 -3z"/>
+<path d="M1710 1301 c0 -5 5 -13 10 -16 6 -3 10 -2 10 4 0 5 -4 13 -10 16 -5
+3 -10 2 -10 -4z"/>
+<path d="M735 1280 c3 -5 8 -10 11 -10 2 0 4 5 4 10 0 6 -5 10 -11 10 -5 0 -7
+-4 -4 -10z"/>
+<path d="M655 1264 c-11 -8 -25 -12 -33 -9 -7 2 -10 0 -7 -5 3 -6 -2 -10 -12
+-10 -10 -1 -29 -8 -43 -16 -17 -11 -19 -13 -5 -9 25 9 46 13 65 15 17 1 81 50
+65 50 -5 -1 -19 -7 -30 -16z"/>
+<path d="M1696 1265 c-3 -8 -1 -15 4 -15 6 0 10 7 10 15 0 8 -2 15 -4 15 -2 0
+-6 -7 -10 -15z"/>
+<path d="M842 1239 c-7 -11 -27 -26 -44 -33 -24 -10 -27 -14 -14 -19 21 -8 63
+18 72 45 8 27 1 31 -14 7z"/>
+<path d="M1534 1252 c4 -7 2 -12 -5 -12 -8 0 -10 -12 -5 -37 11 -68 17 -97 21
+-101 2 -2 -1 -15 -6 -29 -6 -16 -6 -31 1 -41 8 -15 10 -15 10 3 1 11 3 29 5
+40 14 84 13 115 -2 115 -11 0 -14 8 -11 30 3 17 0 34 -5 37 -6 3 -7 1 -3 -5z"/>
+<path d="M806 1235 c-3 -8 -1 -15 3 -15 5 0 11 7 15 15 3 8 1 15 -3 15 -5 0
+-11 -7 -15 -15z"/>
+<path d="M1296 1223 c-8 -25 -6 -39 6 -35 6 2 8 -8 6 -23 -3 -14 -1 -25 4 -25
+9 0 5 86 -5 96 -3 3 -8 -3 -11 -13z"/>
+<path d="M1693 1225 c0 -8 4 -15 9 -15 4 0 8 7 8 15 0 8 -4 15 -8 15 -5 0 -9
+-7 -9 -15z"/>
+<path d="M1730 1230 c0 -5 5 -10 10 -10 6 0 10 5 10 10 0 6 -4 10 -10 10 -5 0
+-10 -4 -10 -10z"/>
+<path d="M1151 1207 c-16 -41 -13 -57 5 -24 8 16 13 34 11 40 -3 7 -10 -1 -16
+-16z"/>
+<path d="M1040 1194 c0 -8 5 -12 10 -9 6 4 8 11 5 16 -9 14 -15 11 -15 -7z"/>
+<path d="M1102 1189 c3 -8 -3 -21 -12 -29 -9 -8 -22 -30 -30 -48 -8 -21 -16
+-29 -20 -22 -5 9 -9 9 -14 1 -4 -6 -4 -15 -1 -21 3 -5 1 -10 -6 -10 -10 0 -10
+-3 -2 -11 13 -13 36 -3 28 12 -4 5 -1 9 4 9 6 0 11 6 11 14 0 8 3 16 8 18 4 2
+19 19 33 38 23 31 25 37 11 49 -13 12 -14 12 -10 0z"/>
+<path d="M480 1181 c0 -7 -7 -20 -16 -29 -18 -17 -48 -26 -38 -11 3 5 1 9 -4
+9 -8 0 -23 -22 -26 -40 -1 -3 -13 -22 -28 -43 -16 -25 -28 -34 -33 -27 -4 6 1
+21 11 34 11 12 8 11 -6 -4 -21 -21 -35 -25 -85 -26 -86 -2 -123 -8 -137 -22
+-6 -6 -16 -12 -21 -12 -4 0 -28 -14 -53 -30 -29 -21 -44 -38 -44 -52 0 -20 1
+-20 13 -5 6 9 28 27 47 41 19 14 45 33 57 41 17 13 26 14 42 5 14 -7 21 -7 21
+0 0 5 9 10 19 10 11 0 23 5 26 10 13 20 53 10 79 -21 31 -37 33 -69 6 -94 -13
+-12 -18 -25 -14 -38 4 -13 2 -17 -5 -13 -6 4 -11 1 -11 -7 0 -19 -28 -42 -38
+-32 -4 4 -1 10 6 12 6 3 12 9 12 15 0 16 -28 -11 -43 -40 -14 -29 -63 -69 -73
+-59 -4 3 6 20 20 38 28 33 29 53 1 25 -20 -20 -26 -20 -19 -1 4 9 0 15 -10 15
+-9 0 -15 -3 -15 -7 1 -5 1 -15 0 -23 -1 -12 -3 -13 -10 -1 -6 9 -11 10 -15 2
+-4 -6 -4 -11 0 -11 4 0 -1 -9 -10 -19 -10 -11 -25 -17 -34 -14 -13 4 -12 2 3
+-10 16 -13 17 -17 6 -31 -12 -14 -12 -16 4 -10 13 5 16 4 11 -4 -4 -7 -2 -12
+3 -12 6 0 11 7 11 15 0 8 6 15 14 15 8 0 16 5 18 12 3 8 13 2 28 -15 13 -15
+30 -27 37 -27 19 0 16 -10 -12 -36 -14 -13 -25 -27 -25 -32 0 -14 -57 -61 -66
+-54 -4 4 -4 1 1 -7 4 -8 2 -17 -6 -22 -8 -5 -9 -9 -3 -9 6 0 21 11 34 25 12
+13 28 22 34 18 6 -3 8 -3 4 1 -10 12 120 179 133 171 13 -9 21 15 9 30 -9 11
+-15 9 -35 -11 -14 -14 -25 -29 -25 -34 0 -11 -3 -12 -39 -14 -40 -2 -33 17 20
+53 60 41 104 94 95 117 -4 10 -1 14 6 12 20 -7 21 -38 3 -58 -11 -12 -13 -20
+-6 -25 6 -3 11 1 11 9 0 8 5 18 11 22 8 4 9 -1 3 -17 -4 -13 -9 -37 -10 -52
+-1 -15 -7 -34 -13 -41 -6 -7 -8 -15 -6 -18 3 -3 1 -17 -4 -32 -9 -23 -9 -25 7
+-15 16 10 19 21 25 89 2 30 11 38 22 20 3 -5 14 -9 23 -9 15 1 15 2 -1 6 -9 2
+-14 9 -11 15 4 7 2 8 -4 4 -7 -4 -12 -1 -12 8 0 8 10 17 23 19 l22 4 -22 2
+c-13 0 -23 4 -24 9 -8 75 -5 102 12 102 6 0 7 -10 3 -22 -6 -20 -4 -20 16 5
+12 15 20 31 16 34 -3 4 -6 1 -6 -5 0 -7 -4 -12 -10 -12 -5 0 -10 7 -10 15 0 9
+-6 12 -15 9 -8 -4 -15 -2 -15 2 0 12 20 41 20 31 0 -5 8 -1 17 9 13 13 15 18
+5 22 -9 3 -6 10 9 23 12 10 17 19 11 19 -14 0 76 84 92 86 24 3 56 17 56 25 0
+16 -30 10 -37 -7 -6 -15 -8 -15 -20 2 -7 10 -13 13 -13 5z m-355 -415 c-18
+-28 -42 -40 -50 -26 -4 6 0 10 8 10 8 0 22 9 32 20 25 27 29 25 10 -4z"/>
+<path d="M922 1156 c-21 -20 -42 -33 -46 -29 -3 3 -6 -1 -6 -10 0 -27 22 -19
+64 23 50 51 41 63 -12 16z"/>
+<path d="M620 1170 c-12 -8 -10 -10 8 -10 13 0 20 4 17 10 -7 12 -6 12 -25 0z"/>
+<path d="M743 1156 c-15 -13 -26 -26 -23 -29 3 -3 21 8 40 24 19 16 29 29 23
+29 -7 0 -25 -11 -40 -24z"/>
+<path d="M1393 1113 c-11 -38 -26 -67 -32 -65 -6 1 -11 -1 -12 -5 0 -5 -2 -16
+-4 -27 -3 -14 -1 -16 8 -7 14 14 30 15 22 1 -3 -5 -1 -10 5 -10 7 0 10 6 7 14
+-3 8 0 33 7 56 17 57 31 35 35 -55 2 -38 7 -75 12 -82 7 -7 6 -14 -1 -18 -14
+-8 -13 -52 2 -61 6 -4 8 -3 4 4 -3 6 -1 23 6 39 6 15 12 42 13 58 1 17 5 41 8
+55 4 14 4 19 1 13 -13 -30 -26 -11 -20 28 4 26 3 38 -4 34 -6 -3 -7 0 -4 9 4
+11 0 16 -13 16 -16 0 -18 6 -15 35 6 53 -2 42 -25 -32z"/>
+<path d="M1683 1174 c3 -3 1 -17 -4 -31 -6 -16 -6 -31 1 -41 7 -14 9 -11 10
+15 0 17 3 38 6 47 4 10 1 16 -7 16 -7 0 -10 -3 -6 -6z"/>
+<path d="M749 1120 c-28 -27 -56 -50 -63 -50 -12 0 -66 -39 -54 -40 4 0 24 9
+45 19 21 11 45 21 53 23 8 2 27 19 42 38 15 19 32 41 38 48 7 8 7 12 0 12 -5
+0 -33 -22 -61 -50z"/>
+<path d="M1263 1149 c-2 -17 1 -18 13 -9 17 15 18 30 1 30 -7 0 -13 -9 -14
+-21z"/>
+<path d="M560 1150 c-13 -9 -13 -10 0 -10 8 0 22 5 30 10 13 9 13 10 0 10 -8
+0 -22 -5 -30 -10z"/>
+<path d="M1119 1133 c-10 -11 -10 -14 -1 -9 6 4 12 2 12 -3 0 -6 -5 -11 -12
+-11 -6 0 -8 -3 -4 -7 9 -9 -54 -73 -73 -74 -9 0 -11 -3 -5 -5 22 -9 87 45 101
+84 15 45 15 42 4 42 -5 0 -15 -8 -22 -17z"/>
+<path d="M494 1124 c-18 -15 -18 -15 2 -5 12 6 24 7 28 4 3 -3 6 -1 6 5 0 16
+-12 15 -36 -4z"/>
+<path d="M591 1124 c0 -11 3 -14 6 -6 3 7 2 16 -1 19 -3 4 -6 -2 -5 -13z"/>
+<path d="M610 1131 c0 -5 5 -13 10 -16 6 -3 10 -2 10 4 0 5 -4 13 -10 16 -5 3
+-10 2 -10 -4z"/>
+<path d="M953 1110 c-9 -11 -20 -15 -23 -10 -3 5 -14 -5 -24 -23 -14 -26 -14
+-28 -1 -12 9 11 21 19 27 17 5 -1 16 2 22 8 7 5 15 7 18 5 3 -3 8 3 11 15 7
+26 -8 26 -30 0z"/>
+<path d="M1280 1115 c-9 -11 -9 -15 -1 -15 7 0 9 -5 5 -12 -4 -7 -3 -10 1 -5
+8 6 16 47 10 47 -2 0 -8 -7 -15 -15z"/>
+<path d="M790 1095 c-20 -24 -6 -27 20 -5 17 15 19 20 8 20 -9 0 -21 -7 -28
+-15z"/>
+<path d="M547 1084 c4 -10 10 -11 24 -3 24 13 24 14 -5 15 -17 1 -23 -2 -19
+-12z"/>
+<path d="M1625 1090 c-3 -5 -1 -10 4 -10 6 0 11 5 11 10 0 6 -2 10 -4 10 -3 0
+-8 -4 -11 -10z"/>
+<path d="M864 1082 c3 -5 -4 -19 -15 -30 -11 -12 -16 -22 -11 -22 12 0 42 34
+42 48 0 7 -5 12 -11 12 -5 0 -8 -4 -5 -8z"/>
+<path d="M1261 1074 c0 -11 3 -14 6 -6 3 7 2 16 -1 19 -3 4 -6 -2 -5 -13z"/>
+<path d="M440 1069 c0 -5 11 -9 25 -9 14 0 25 2 25 4 0 2 -11 6 -25 8 -14 3
+-25 1 -25 -3z"/>
+<path d="M967 1062 c-24 -27 -21 -36 4 -11 11 11 19 23 16 25 -2 2 -11 -4 -20
+-14z"/>
+<path d="M580 1055 c0 -8 2 -15 4 -15 2 0 6 7 10 15 3 8 1 15 -4 15 -6 0 -10
+-7 -10 -15z"/>
+<path d="M1612 1039 c-2 -18 2 -28 8 -24 5 3 8 15 7 25 -5 32 -13 31 -15 -1z"/>
+<path d="M1143 1048 c-13 -16 -26 -58 -19 -58 8 0 38 61 33 66 -2 3 -9 -1 -14
+-8z"/>
+<path d="M694 1035 c-10 -8 -14 -15 -8 -15 6 0 17 7 24 15 16 19 9 19 -16 0z"/>
+<path d="M722 1028 c-15 -15 -16 -31 0 -26 6 2 12 12 14 21 3 20 2 21 -14 5z"/>
+<path d="M970 1000 c-17 -22 -27 -40 -21 -40 6 0 11 4 11 9 0 5 14 23 31 40
+17 17 26 31 21 31 -6 0 -25 -18 -42 -40z"/>
+<path d="M1095 1020 c-20 -22 -85 -63 -84 -52 5 30 -3 34 -19 9 -10 -15 -28
+-36 -40 -48 -12 -11 -22 -24 -22 -29 0 -12 30 -14 30 -2 0 4 10 18 21 32 17
+21 20 22 15 5 -6 -19 -5 -19 8 -2 8 10 17 18 20 18 15 -2 85 52 89 70 6 24 4
+24 -18 -1z"/>
+<path d="M1664 1015 c7 -36 12 -41 19 -16 3 11 -2 26 -10 32 -12 10 -13 8 -9
+-16z"/>
+<path d="M1710 1030 c0 -5 5 -10 10 -10 6 0 10 5 10 10 0 6 -4 10 -10 10 -5 0
+-10 -4 -10 -10z"/>
+<path d="M433 1023 c-7 -2 -13 -9 -13 -15 0 -7 4 -7 13 0 6 5 21 12 32 15 20
+5 20 5 0 5 -11 0 -26 -2 -32 -5z"/>
+<path d="M591 1013 c-1 -17 16 -25 25 -12 4 7 3 9 -4 5 -5 -3 -13 0 -15 6 -4
+9 -6 10 -6 1z"/>
+<path d="M790 1005 c-6 -8 -10 -19 -8 -24 4 -14 51 10 54 27 1 7 0 8 -3 2 -3
+-8 -9 -8 -18 0 -9 7 -16 6 -25 -5z"/>
+<path d="M912 1011 c-11 -6 -10 -10 4 -15 15 -6 13 -11 -14 -37 -18 -17 -32
+-36 -32 -41 0 -5 -10 -6 -22 -3 -13 3 -18 3 -13 -2 10 -7 11 -15 6 -40 0 -4
+-6 -2 -13 5 -7 7 -17 12 -22 12 -6 0 -1 -7 11 -15 18 -13 26 -13 43 -3 11 7
+20 18 20 24 0 6 16 33 35 60 19 27 35 52 35 56 0 10 -22 10 -38 -1z"/>
+<path d="M241 994 c0 -12 -18 -43 -40 -70 -36 -46 -37 -49 -16 -49 14 0 21 5
+18 13 -7 17 17 44 33 38 8 -3 20 1 28 9 19 20 26 19 27 -2 0 -15 2 -15 8 2 8
+21 4 45 -7 43 -24 -3 -41 4 -45 20 -4 13 -5 13 -6 -4z"/>
+<path d="M455 994 c-16 -7 -33 -10 -37 -7 -5 2 -8 -3 -8 -13 0 -12 4 -14 13
+-7 12 10 58 24 89 28 30 3 30 12 1 12 -16 0 -41 -6 -58 -13z"/>
+<path d="M630 980 c-13 -11 -21 -22 -18 -25 3 -3 17 6 32 20 32 30 20 34 -14
+5z"/>
+<path d="M116 974 c-3 -8 -10 -13 -15 -9 -5 3 -13 -5 -17 -17 -4 -13 -11 -26
+-17 -29 -6 -4 -5 -13 2 -25 9 -17 10 -17 11 -1 0 9 6 17 14 17 7 0 16 14 20
+31 3 17 10 28 16 24 5 -3 10 -2 10 4 0 17 -18 21 -24 5z"/>
+<path d="M1317 965 c-2 -14 -1 -27 2 -29 4 -3 8 -18 9 -35 2 -24 -1 -29 -13
+-25 -10 4 -15 0 -15 -12 0 -11 -9 -32 -20 -49 -11 -16 -20 -37 -20 -45 0 -8
+11 5 25 29 14 23 25 50 25 59 0 14 2 14 13 -1 11 -15 12 -14 14 10 0 15 6 29
+12 31 6 2 10 22 10 45 -2 31 -3 34 -6 14 -2 -15 -8 -25 -13 -22 -4 3 -6 14 -3
+24 3 10 0 21 -5 25 -5 3 -12 -6 -15 -19z"/>
+<path d="M728 964 c-16 -8 -28 -20 -28 -27 0 -9 2 -9 8 0 4 6 20 15 35 18 15
+4 27 11 27 16 0 12 -10 11 -42 -7z"/>
+<path d="M475 960 c-3 -5 -14 -10 -25 -10 -10 0 -21 -7 -24 -16 -9 -24 -1 -28
+17 -9 17 17 31 20 22 5 -12 -19 26 -23 58 -7 31 16 31 16 5 11 -40 -9 -64 2
+-48 21 7 8 10 15 7 15 -3 0 -9 -4 -12 -10z"/>
+<path d="M1650 963 c5 -2 8 -9 4 -14 -3 -5 0 -9 6 -9 15 0 7 23 -8 26 -7 1 -8
+0 -2 -3z"/>
+<path d="M777 930 c3 -11 10 -23 16 -27 6 -4 7 -1 2 7 -6 10 -4 12 9 7 22 -9
+11 9 -14 23 -15 8 -17 7 -13 -10z"/>
+<path d="M1095 920 c-16 -16 -27 -31 -24 -33 2 -2 17 11 32 30 36 41 31 43 -8
+3z"/>
+<path d="M1379 928 c0 -13 -2 -33 -3 -46 -2 -13 2 -21 8 -19 13 4 17 87 4 87
+-4 0 -8 -10 -9 -22z"/>
+<path d="M1605 940 c3 -5 8 -10 11 -10 2 0 4 5 4 10 0 6 -5 10 -11 10 -5 0 -7
+-4 -4 -10z"/>
+<path d="M668 933 c7 -3 16 -2 19 1 4 3 -2 6 -13 5 -11 0 -14 -3 -6 -6z"/>
+<path d="M1147 927 c-3 -8 1 -14 9 -14 16 0 19 13 5 21 -5 3 -11 0 -14 -7z"/>
+<path d="M1269 901 c-14 -15 -33 -32 -42 -37 -11 -7 -13 -14 -7 -24 8 -12 13
+-10 32 14 13 16 31 36 41 45 18 16 23 32 10 30 -5 0 -20 -13 -34 -28z"/>
+<path d="M1660 894 c0 -19 4 -33 8 -30 8 5 4 66 -4 66 -2 0 -4 -16 -4 -36z"/>
+<path d="M395 912 c-18 -13 -14 -28 8 -29 16 -2 18 0 8 6 -7 5 -10 14 -7 20 8
+13 5 14 -9 3z"/>
+<path d="M574 906 c-10 -8 -17 -17 -14 -19 3 -3 16 3 29 14 27 22 15 26 -15 5z"/>
+<path d="M1500 901 c-12 -24 -13 -34 -1 -27 9 6 22 46 15 46 -2 0 -8 -9 -14
+-19z"/>
+<path d="M26 877 c-10 -22 -15 -44 -13 -50 3 -7 10 2 17 18 l12 30 9 -24 c5
+-13 12 -21 16 -17 3 3 1 16 -5 29 -6 12 -13 29 -15 37 -3 10 -11 1 -21 -23z"/>
+<path d="M482 891 c-11 -7 -11 -9 1 -14 9 -3 18 1 21 9 6 16 -2 18 -22 5z"/>
+<path d="M1173 892 c-6 -4 -14 -21 -17 -37 -6 -28 -6 -29 4 -6 6 14 16 31 22
+38 12 15 9 16 -9 5z"/>
+<path d="M1013 863 c-36 -34 -49 -63 -27 -63 8 0 13 4 10 9 -3 4 6 19 19 31
+14 13 25 18 25 11 0 -7 5 -9 10 -6 12 7 13 45 2 45 -5 0 -22 -12 -39 -27z"/>
+<path d="M104 865 c-10 -8 -14 -15 -8 -15 6 0 17 7 24 15 16 19 9 19 -16 0z"/>
+<path d="M1095 869 c-4 -6 -5 -12 -2 -15 2 -3 7 2 10 11 7 17 1 20 -8 4z"/>
+<path d="M761 854 c0 -11 3 -14 6 -6 3 7 2 16 -1 19 -3 4 -6 -2 -5 -13z"/>
+<path d="M365 850 c3 -5 8 -10 11 -10 2 0 4 5 4 10 0 6 -5 10 -11 10 -5 0 -7
+-4 -4 -10z"/>
+<path d="M900 849 c0 -5 5 -7 10 -4 6 3 10 8 10 11 0 2 -4 4 -10 4 -5 0 -10
+-5 -10 -11z"/>
+<path d="M952 848 c-15 -15 -16 -31 0 -26 6 2 12 12 14 21 3 20 2 21 -14 5z"/>
+<path d="M1411 853 c-1 -7 8 -17 19 -23 14 -7 20 -7 20 0 0 5 -6 10 -14 10 -8
+0 -17 6 -19 13 -4 9 -6 9 -6 0z"/>
+<path d="M1469 833 c-18 -47 -26 -58 -38 -59 -6 -1 -14 -2 -18 -3 -4 0 2 -8
+13 -17 18 -15 18 -15 0 -10 -17 6 -17 5 -5 -11 9 -11 10 -14 1 -9 -8 5 -15 -2
+-22 -18 -5 -14 -16 -26 -25 -26 -8 0 -15 -7 -15 -16 0 -8 -4 -12 -10 -9 -5 3
+-10 -1 -10 -9 0 -8 8 -19 17 -24 15 -9 14 -11 -5 -23 -13 -8 -18 -17 -12 -24
+12 -14 -12 -61 -29 -57 -7 1 -10 -2 -7 -7 4 -5 0 -12 -6 -14 -7 -3 -8 -6 -3
+-6 20 -1 45 27 65 73 24 58 25 64 3 68 -14 3 -9 10 19 28 21 14 36 31 33 38
+-2 6 1 12 8 12 13 0 50 74 63 124 8 34 -4 33 -17 -1z"/>
+<path d="M679 831 c-13 -11 -22 -22 -19 -24 3 -3 16 5 29 19 28 29 22 31 -10
+5z"/>
+<path d="M555 821 c-3 -5 -1 -12 4 -15 5 -3 11 1 15 9 6 16 -9 21 -19 6z"/>
+<path d="M1110 815 c0 -8 -5 -14 -12 -12 -7 1 -13 -5 -14 -13 0 -8 -2 -21 -2
+-28 -1 -7 -8 -12 -14 -11 -27 3 -38 -1 -38 -15 0 -8 4 -17 9 -20 5 -3 8 0 7 7
+0 6 4 12 9 12 6 0 9 -4 7 -10 -2 -5 8 4 22 20 29 35 50 85 35 85 -5 0 -9 -7
+-9 -15z"/>
+<path d="M1166 814 c-4 -9 -4 -19 -1 -22 2 -3 7 3 11 12 4 9 4 19 1 22 -2 3
+-7 -3 -11 -12z"/>
+<path d="M1200 809 c0 -5 5 -7 10 -4 6 3 10 8 10 11 0 2 -4 4 -10 4 -5 0 -10
+-5 -10 -11z"/>
+<path d="M1 736 c-1 -64 0 -69 12 -46 7 14 10 27 5 31 -4 3 -3 21 2 39 13 45
+13 47 -4 47 -9 0 -14 -19 -15 -71z"/>
+<path d="M1310 795 c-7 -8 -9 -23 -5 -36 6 -18 4 -21 -10 -15 -15 5 -16 4 -6
+-8 9 -11 10 -24 2 -52 -5 -20 -7 -34 -4 -30 8 8 34 75 37 96 1 8 8 25 14 38
+11 18 10 22 -1 22 -8 0 -20 -7 -27 -15z"/>
+<path d="M624 778 c-11 -13 -30 -28 -44 -35 -20 -9 -21 -12 -6 -12 15 -1 16
+-4 6 -16 -9 -10 -9 -15 -1 -15 10 0 15 13 12 33 0 4 6 7 14 7 15 0 51 47 42
+56 -2 3 -13 -5 -23 -18z"/>
+<path d="M409 788 c-12 -40 23 -62 42 -27 9 18 7 19 -17 13 -19 -5 -25 -4 -20
+5 4 6 5 11 2 11 -3 0 -6 -1 -7 -2z"/>
+<path d="M935 780 c-3 -5 -2 -10 4 -10 5 0 13 5 16 10 3 6 2 10 -4 10 -5 0
+-13 -4 -16 -10z"/>
+<path d="M660 770 c0 -5 5 -10 11 -10 5 0 7 5 4 10 -3 6 -8 10 -11 10 -2 0 -4
+-4 -4 -10z"/>
+<path d="M1222 760 c-8 -13 -8 -20 -2 -20 6 0 13 7 17 15 9 24 -1 27 -15 5z"/>
+<path d="M827 763 c-4 -3 -7 -11 -7 -17 0 -6 5 -5 12 2 6 6 9 14 7 17 -3 3 -9
+2 -12 -2z"/>
+<path d="M1002 765 c5 -5 -1 -14 -12 -22 -11 -8 -20 -22 -19 -31 0 -14 2 -14
+6 -2 4 8 15 22 26 31 17 13 18 17 6 24 -8 5 -11 5 -7 0z"/>
+<path d="M355 750 c3 -6 1 -10 -5 -10 -6 0 -9 -4 -5 -10 6 -10 35 -2 35 10 0
+4 -7 11 -16 14 -8 3 -12 2 -9 -4z"/>
+<path d="M1185 730 c-3 -5 -1 -10 4 -10 6 0 11 5 11 10 0 6 -2 10 -4 10 -3 0
+-8 -4 -11 -10z"/>
+<path d="M1469 733 c-1 -5 -1 -12 0 -17 1 -4 -6 -14 -16 -22 -16 -13 -16 -13
+6 -6 26 9 41 32 21 32 -6 0 -8 5 -5 10 3 6 4 10 1 10 -3 0 -7 -3 -7 -7z"/>
+<path d="M1147 701 c-4 -17 -2 -18 13 -8 10 6 16 15 14 19 -9 14 -22 9 -27
+-11z"/>
+<path d="M780 701 c0 -5 -12 -8 -27 -6 -26 3 -26 2 -8 -12 20 -15 20 -15 0
+-11 -15 4 -21 0 -21 -13 0 -11 4 -19 8 -19 4 0 8 5 8 10 0 6 6 10 14 10 8 0
+17 7 20 16 3 8 10 12 16 9 6 -3 7 1 4 9 -7 18 -14 21 -14 7z"/>
+<path d="M810 706 c0 -2 7 -7 16 -10 8 -3 12 -2 9 4 -6 10 -25 14 -25 6z"/>
+<path d="M1590 696 c7 -7 14 -6 21 1 9 9 7 12 -9 10 -14 -1 -18 -5 -12 -11z"/>
+<path d="M89 666 c-17 -19 -37 -32 -43 -30 -6 2 -20 -10 -30 -26 -19 -34 -17
+-50 4 -25 7 8 16 15 20 15 4 0 30 23 57 50 28 28 44 50 37 50 -7 0 -27 -15
+-45 -34z"/>
+<path d="M250 663 c-12 -21 -31 -43 -41 -51 -18 -13 -27 -42 -11 -42 4 0 18
+16 32 35 29 39 46 45 35 13 -3 -13 -6 -30 -6 -38 3 -56 0 -83 -8 -99 -14 -26
+-21 -71 -11 -71 7 0 20 38 25 70 0 3 4 10 8 16 10 17 17 204 7 204 -4 0 -18
+-17 -30 -37z"/>
+<path d="M375 690 c-3 -5 1 -10 9 -10 9 0 16 5 16 10 0 6 -4 10 -9 10 -6 0
+-13 -4 -16 -10z"/>
+<path d="M880 685 c-11 -13 -10 -14 4 -9 9 3 16 10 16 15 0 13 -6 11 -20 -6z"/>
+<path d="M923 687 c-3 -6 -1 -7 5 -3 7 4 12 2 12 -4 0 -6 5 -8 10 -5 6 3 10
+10 10 14 0 11 -30 9 -37 -2z"/>
+<path d="M1063 685 c-3 -9 -3 -19 1 -22 3 -4 6 1 6 10 0 10 4 17 8 17 14 0 32
+-23 32 -42 0 -16 3 -16 20 -6 18 12 19 13 2 19 -10 4 -24 14 -31 23 -17 20
+-30 20 -38 1z"/>
+<path d="M987 676 c-4 -10 0 -14 12 -13 11 1 17 7 14 14 -7 17 -20 17 -26 -1z"/>
+<path d="M1576 663 c-6 -14 -5 -15 5 -6 7 7 10 15 7 18 -3 3 -9 -2 -12 -12z"/>
+<path d="M1073 655 c-7 -8 -13 -19 -13 -25 0 -5 -4 -10 -10 -10 -5 0 -10 -6
+-10 -12 1 -15 50 38 50 53 0 12 -2 11 -17 -6z"/>
+<path d="M950 638 c0 -4 7 -8 15 -8 8 0 15 4 15 8 0 5 -7 9 -15 9 -8 0 -15 -4
+-15 -9z"/>
+<path d="M1215 640 c4 -6 11 -8 16 -5 14 9 11 15 -7 15 -8 0 -12 -5 -9 -10z"/>
+<path d="M480 620 c-13 -8 -12 -10 3 -10 9 0 17 5 17 10 0 12 -1 12 -20 0z"/>
+<path d="M894 622 c-6 -4 -14 -16 -17 -27 -7 -20 -7 -20 8 -1 8 11 21 23 27
+28 7 4 9 8 3 8 -5 0 -15 -4 -21 -8z"/>
+<path d="M728 608 c5 -5 16 -8 23 -6 8 3 3 7 -10 11 -17 4 -21 3 -13 -5z"/>
+<path d="M1405 610 c-3 -6 1 -7 9 -4 18 7 21 14 7 14 -6 0 -13 -4 -16 -10z"/>
+<path d="M1440 599 c0 -23 10 -28 35 -18 18 7 18 8 1 8 -11 1 -16 6 -13 14 3
+8 -1 14 -9 14 -8 0 -14 -8 -14 -18z"/>
+<path d="M813 595 c0 -8 4 -12 9 -9 5 3 6 10 3 15 -9 13 -12 11 -12 -6z"/>
+<path d="M1271 573 c2 -24 2 -25 6 -5 2 12 9 20 14 17 5 -4 9 -1 9 4 0 6 -7
+11 -15 11 -10 0 -15 -9 -14 -27z"/>
+<path d="M1125 580 c-3 -5 -1 -10 4 -10 6 0 11 5 11 10 0 6 -2 10 -4 10 -3 0
+-8 -4 -11 -10z"/>
+<path d="M1163 565 c0 -8 4 -12 9 -9 5 3 6 10 3 15 -9 13 -12 11 -12 -6z"/>
+<path d="M1880 573 c0 -5 7 -19 16 -31 8 -12 12 -22 9 -22 -3 0 1 -10 9 -22
+20 -28 20 -42 2 -35 -11 4 -11 1 -2 -18 6 -13 14 -21 18 -19 4 3 10 -8 13 -23
+4 -15 11 -38 16 -51 7 -17 6 -21 -3 -16 -8 5 -9 2 -4 -12 5 -10 9 -26 10 -34
+0 -8 5 -18 9 -21 5 -4 7 -16 5 -29 -3 -22 -3 -22 -25 -2 -13 10 -19 23 -15 27
+4 5 1 5 -5 1 -10 -5 -9 -13 3 -32 9 -13 20 -24 25 -24 5 0 9 -12 9 -27 0 -23
+-2 -25 -11 -13 -9 12 -10 11 -4 -5 4 -11 9 -53 12 -92 4 -55 10 -73 20 -73 13
+0 14 25 10 162 -4 147 -8 172 -35 254 -16 50 -37 104 -46 122 -16 31 -36 50
+-36 35z"/>
+<path d="M30 548 c-12 -22 -12 -22 6 -6 10 10 15 20 12 24 -4 3 -12 -5 -18
+-18z"/>
+<path d="M430 559 c0 -5 5 -7 10 -4 6 3 10 8 10 11 0 2 -4 4 -10 4 -5 0 -10
+-5 -10 -11z"/>
+<path d="M1212 550 c-7 -11 -8 -20 -3 -20 9 0 24 30 18 36 -1 2 -8 -6 -15 -16z"/>
+<path d="M165 544 c21 -16 19 -37 -6 -52 -12 -8 -18 -19 -15 -28 3 -8 1 -14
+-5 -14 -6 0 -8 -9 -4 -19 4 -13 -5 -37 -24 -67 -16 -27 -27 -52 -24 -57 7 -12
+47 59 67 121 19 56 38 78 58 66 10 -6 9 -3 -1 9 -8 11 -9 17 -3 17 6 0 16 10
+22 23 9 18 9 20 -2 7 -18 -20 -42 -25 -35 -7 4 11 -2 14 -19 13 -20 -1 -22 -3
+-9 -12z"/>
+<path d="M998 553 c6 -2 9 -10 6 -15 -4 -7 -2 -8 5 -4 13 9 5 26 -12 25 -9 0
+-8 -2 1 -6z"/>
+<path d="M1463 540 c1 -21 12 -26 22 -10 3 6 1 10 -5 10 -6 0 -8 5 -5 10 3 6
+2 10 -4 10 -5 0 -9 -9 -8 -20z"/>
+<path d="M1045 518 c-4 -18 -17 -42 -29 -53 -12 -11 -17 -17 -11 -13 7 4 15 5
+18 1 4 -3 9 1 13 10 3 9 11 15 17 13 7 -1 9 -1 6 1 -3 2 -4 19 -2 38 4 44 -3
+45 -12 3z"/>
+<path d="M130 530 c-13 -8 -12 -10 3 -10 9 0 17 5 17 10 0 12 -1 12 -20 0z"/>
+<path d="M570 525 c-8 -9 -8 -15 -2 -15 12 0 26 19 19 26 -2 2 -10 -2 -17 -11z"/>
+<path d="M712 501 c-16 -17 -33 -27 -36 -23 -4 3 -4 -1 -1 -10 6 -14 12 -11
+41 19 19 20 33 37 31 40 -3 2 -18 -10 -35 -26z"/>
+<path d="M850 516 c0 -8 4 -17 9 -20 5 -4 7 3 4 14 -6 23 -13 26 -13 6z"/>
+<path d="M1436 516 c3 -9 1 -23 -6 -31 -7 -8 -8 -15 -4 -15 5 0 15 9 21 19 10
+16 9 22 -3 32 -12 10 -13 9 -8 -5z"/>
+<path d="M1260 510 c-8 -5 -10 -10 -5 -10 6 0 17 5 25 10 8 5 11 10 5 10 -5 0
+-17 -5 -25 -10z"/>
+<path d="M106 499 c10 -17 -56 -72 -71 -59 -8 7 -16 3 -25 -15 -7 -14 -10 -28
+-6 -32 4 -4 9 3 13 16 3 14 11 20 20 17 8 -3 32 11 55 32 34 32 38 40 24 45
+-11 5 -15 3 -10 -4z"/>
+<path d="M1225 500 c-3 -5 -1 -10 4 -10 6 0 11 5 11 10 0 6 -2 10 -4 10 -3 0
+-8 -4 -11 -10z"/>
+<path d="M635 474 c-9 -15 -12 -23 -6 -20 6 4 11 2 11 -3 0 -6 5 -11 11 -11 8
+0 8 5 -1 15 -7 8 -8 15 -3 15 5 0 10 7 10 15 0 20 -2 19 -22 -11z"/>
+<path d="M100 421 c0 -5 -6 -16 -12 -23 -51 -53 -40 -69 11 -17 34 34 39 49
+16 49 -8 0 -15 -4 -15 -9z"/>
+<path d="M176 388 c0 -23 6 -44 12 -46 14 -4 15 -55 2 -100 -8 -29 -7 -32 5
+-22 17 14 30 93 20 117 -15 33 -15 56 -3 71 11 13 10 15 -3 10 -9 -4 -21 -2
+-25 2 -6 6 -9 -8 -8 -32z"/>
+<path d="M735 420 c-3 -6 1 -7 9 -4 18 7 21 14 7 14 -6 0 -13 -4 -16 -10z"/>
+<path d="M1305 380 c-3 -5 1 -10 10 -10 9 0 13 5 10 10 -3 6 -8 10 -10 10 -2
+0 -7 -4 -10 -10z"/>
+<path d="M825 370 c-3 -5 -21 -10 -38 -10 -21 0 -28 -3 -19 -9 8 -4 13 -11 13
+-15 -4 -29 13 -37 22 -12 4 11 1 13 -11 9 -14 -5 -15 -3 -5 7 9 10 15 10 26 1
+15 -11 22 -7 41 27 9 14 -20 17 -29 2z"/>
+<path d="M11 323 c-10 -26 -10 -27 4 -9 8 11 15 23 15 28 0 15 -7 8 -19 -19z"/>
+<path d="M483 335 c-3 -9 -3 -18 -1 -21 3 -3 8 4 11 16 6 23 -1 27 -10 5z"/>
+<path d="M1840 340 c0 -5 5 -10 11 -10 5 0 7 5 4 10 -3 6 -8 10 -11 10 -2 0
+-4 -4 -4 -10z"/>
+<path d="M570 320 c0 -5 5 -10 11 -10 5 0 7 5 4 10 -3 6 -8 10 -11 10 -2 0 -4
+-4 -4 -10z"/>
+<path d="M873 317 c0 -8 6 -14 14 -14 9 0 10 4 2 14 -6 7 -12 13 -14 13 -1 0
+-2 -6 -2 -13z"/>
+<path d="M1356 317 c3 -10 9 -15 12 -12 3 3 0 11 -7 18 -10 9 -11 8 -5 -6z"/>
+<path d="M166 297 c3 -10 9 -15 12 -12 3 3 0 11 -7 18 -10 9 -11 8 -5 -6z"/>
+<path d="M94 285 c-10 -8 -15 -15 -10 -15 5 0 4 -6 -1 -12 -5 -7 -10 -29 -11
+-48 0 -33 0 -32 13 13 7 26 19 54 25 62 16 19 9 19 -16 0z"/>
+<path d="M492 284 c-12 -8 -28 -12 -35 -8 -6 4 -5 -1 4 -11 13 -13 21 -15 37
+-6 20 11 38 41 24 41 -4 0 -18 -7 -30 -16z"/>
+<path d="M590 291 c0 -6 5 -11 11 -11 5 0 7 -4 4 -10 -3 -5 -1 -10 4 -10 16 0
+13 16 -4 30 -10 9 -15 9 -15 1z"/>
+<path d="M747 293 c-4 -3 -7 -13 -7 -22 1 -13 3 -13 11 2 11 19 8 33 -4 20z"/>
+<path d="M127 283 c-11 -18 -4 -63 9 -63 16 0 19 16 4 25 -6 4 -8 15 -5 26 6
+19 1 26 -8 12z"/>
+<path d="M627 256 c-3 -8 5 -22 19 -33 13 -10 22 -24 19 -30 -9 -26 11 -12 28
+19 13 23 21 28 26 19 7 -10 9 -9 14 2 3 9 -1 18 -9 21 -8 3 -17 0 -20 -7 -7
+-19 -44 -14 -59 7 -11 14 -14 14 -18 2z"/>
+<path d="M1075 250 c-10 -11 -14 -20 -9 -20 5 0 17 9 27 20 9 11 13 20 8 20
+-4 0 -16 -9 -26 -20z"/>
+<path d="M1155 261 c-3 -5 -2 -12 3 -15 5 -3 9 1 9 9 0 17 -3 19 -12 6z"/>
+<path d="M1450 245 c-7 -8 -16 -12 -21 -9 -5 3 -9 -2 -9 -10 0 -9 7 -16 15
+-16 8 0 15 7 15 15 0 7 8 19 18 24 9 6 12 11 6 11 -6 0 -17 -7 -24 -15z"/>
+<path d="M1516 233 c10 -40 15 -42 12 -5 -1 18 -6 32 -10 32 -5 0 -5 -12 -2
+-27z"/>
+<path d="M40 219 c0 -5 5 -7 10 -4 6 3 10 8 10 11 0 2 -4 4 -10 4 -5 0 -10 -5
+-10 -11z"/>
+<path d="M1010 189 c0 -5 5 -7 10 -4 6 3 10 8 10 11 0 2 -4 4 -10 4 -5 0 -10
+-5 -10 -11z"/>
+<path d="M1136 192 c-3 -5 1 -9 9 -9 8 0 12 4 9 9 -3 4 -7 8 -9 8 -2 0 -6 -4
+-9 -8z"/>
+<path d="M583 175 c-7 -8 -13 -18 -13 -22 0 -4 -11 -21 -25 -37 -30 -35 -31
+-40 -5 -24 10 7 27 27 37 45 9 17 20 30 25 27 4 -3 5 2 2 10 -7 19 -6 19 -21
+1z"/>
+<path d="M920 181 c0 -6 4 -13 10 -16 6 -3 7 1 4 9 -7 18 -14 21 -14 7z"/>
+<path d="M1531 170 c0 -8 4 -24 9 -35 9 -20 9 -20 9 0 0 11 -4 27 -9 35 -9 13
+-10 13 -9 0z"/>
+<path d="M1418 156 c-10 -7 -18 -19 -18 -26 0 -7 9 -3 20 10 28 33 27 39 -2
+16z"/>
+<path d="M520 145 c0 -8 2 -15 4 -15 2 0 6 7 10 15 3 8 1 15 -4 15 -6 0 -10
+-7 -10 -15z"/>
+<path d="M1602 140 c0 -14 2 -19 5 -12 2 6 2 18 0 25 -3 6 -5 1 -5 -13z"/>
+<path d="M730 129 c0 -10 5 -21 12 -25 7 -4 8 -3 4 5 -4 6 -3 18 3 25 8 9 7
+13 -4 13 -8 0 -15 -8 -15 -18z"/>
+<path d="M666 131 c-4 -7 -5 -15 -2 -18 9 -9 19 4 14 18 -4 11 -6 11 -12 0z"/>
+<path d="M496 121 c-5 -7 -18 -16 -30 -21 -20 -8 -20 -9 -1 -9 27 -1 48 14 43
+30 -3 10 -6 10 -12 0z"/>
+<path d="M923 114 c-15 -16 -16 -24 -4 -24 8 0 24 30 19 35 -2 2 -9 -3 -15
+-11z"/>
+<path d="M1497 103 c-3 -16 -3 -30 -1 -33 7 -7 24 23 24 43 0 27 -17 20 -23
+-10z"/>
+<path d="M832 105 c3 -3 -5 -18 -17 -31 -13 -14 -21 -32 -18 -40 6 -16 26 -8
+20 9 -2 6 7 21 20 33 21 20 22 22 6 28 -10 4 -15 4 -11 1z"/>
+<path d="M380 75 c-7 -9 -10 -18 -6 -22 3 -3 6 -1 6 6 0 7 3 10 8 8 4 -3 13 1
+20 9 10 11 10 14 -1 14 -8 0 -20 -7 -27 -15z"/>
+<path d="M1026 73 c-6 -14 -5 -15 5 -6 7 7 10 15 7 18 -3 3 -9 -2 -12 -12z"/>
+<path d="M450 65 c-7 -8 -8 -15 -2 -15 5 0 15 7 22 15 7 8 8 15 2 15 -5 0 -15
+-7 -22 -15z"/>
+<path d="M1920 71 c0 -6 5 -13 11 -16 6 -4 8 -14 4 -22 -4 -13 -3 -14 9 -4 13
+11 13 15 -2 32 -19 21 -22 23 -22 10z"/>
+<path d="M66 61 c-6 -9 9 -61 18 -61 2 0 6 8 8 18 6 21 -17 58 -26 43z"/>
+<path d="M1391 63 c-1 -17 16 -25 25 -12 4 7 3 9 -4 5 -5 -3 -13 0 -15 6 -4 9
+-6 10 -6 1z"/>
+<path d="M280 50 c-8 -5 -12 -11 -9 -14 2 -3 11 -1 19 4 8 5 12 11 9 14 -2 3
+-11 1 -19 -4z"/>
+<path d="M1252 40 c0 -14 2 -19 5 -12 2 6 2 18 0 25 -3 6 -5 1 -5 -13z"/>
+<path d="M1465 50 c-3 -5 -1 -10 4 -10 6 0 11 5 11 10 0 6 -2 10 -4 10 -3 0
+-8 -4 -11 -10z"/>
+<path d="M1626 48 c-7 -21 -3 -48 5 -43 4 3 6 13 5 23 -2 9 4 20 13 24 14 6
+14 7 -2 7 -10 1 -19 -5 -21 -11z"/>
+<path d="M7 25 c-4 -26 -4 -26 14 -6 23 24 24 31 5 31 -7 0 -16 -11 -19 -25z"/>
+<path d="M1520 38 c0 -9 -8 -22 -17 -27 -16 -9 -16 -10 -2 -11 24 0 40 23 29
+40 -8 13 -10 12 -10 -2z"/>
+<path d="M930 31 c0 -6 4 -13 10 -16 6 -3 7 1 4 9 -7 18 -14 21 -14 7z"/>
+<path d="M735 20 c-3 -5 -1 -10 4 -10 6 0 11 5 11 10 0 6 -2 10 -4 10 -3 0 -8
+-4 -11 -10z"/>
+</g>
+<path d="M0 0 h 300 v 15 h -300 z"/>
+<path d="M0 285 h 300 v 15 h -300 z"/>
+<path d="M0 0 v 300 h 15 v -300 z"/>
+<path d="M285 0 v 300 h 15 v -300 z"/>
+</svg>

src/allocator.rs

@@ -1,9 +1,9 @@
-use prolog_parser::ast::*;
+use crate::prolog_parser::ast::*;
 
-use crate::prolog::fixtures::*;
-use crate::prolog::forms::*;
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::targets::*;
+use crate::fixtures::*;
+use crate::forms::*;
+use crate::machine::machine_indices::*;
+use crate::targets::*;
 
 use std::cell::Cell;
 use std::rc::Rc;

src/arithmetic.rs

@@ -1,18 +1,18 @@
-use prolog_parser::ast::*;
+use crate::prolog_parser::ast::*;
 
-use crate::prolog::clause_types::*;
-use crate::prolog::fixtures::*;
-use crate::prolog::forms::*;
-use crate::prolog::instructions::*;
-use crate::prolog::iterators::*;
+use crate::clause_types::*;
+use crate::fixtures::*;
+use crate::forms::*;
+use crate::instructions::*;
+use crate::iterators::*;
 
-use crate::prolog::machine::heap::*;
-use crate::prolog::machine::machine_errors::*;
-use crate::prolog::machine::machine_indices::*;
+use crate::machine::heap::*;
+use crate::machine::machine_errors::*;
+use crate::machine::machine_indices::*;
 
-use crate::prolog::ordered_float::*;
-use crate::prolog::rug::ops::PowAssign;
-use crate::prolog::rug::{Assign, Integer, Rational};
+use crate::ordered_float::*;
+use crate::rug::ops::PowAssign;
+use crate::rug::{Assign, Integer, Rational};
 
 use std::cell::Cell;
 use std::cmp::{max, min, Ordering};
@@ -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>,
@@ -471,7 +474,12 @@ impl Neg for Number {
 
     fn neg(self) -> Self::Output {
         match self {
-            Number::Fixnum(n) => Number::Fixnum(-n),
+            Number::Fixnum(n) =>
+                if let Some(n) = n.checked_neg() {
+                    Number::Fixnum(n)
+                } else {
+                    Number::from(-Integer::from(n))
+                }
             Number::Integer(n) => Number::Integer(Rc::new(-Integer::from(&*n))),
             Number::Float(OrderedFloat(f)) => Number::Float(OrderedFloat(-f)),
             Number::Rational(r) => Number::Rational(Rc::new(-Rational::from(&*r))),
@@ -632,15 +640,33 @@ impl PartialEq for Number {
             (&Number::Integer(ref n1), &Number::Fixnum(n2)) => (&**n1).eq(&n2),
             (&Number::Fixnum(n1), &Number::Rational(ref n2)) => n1.eq(&**n2),
             (&Number::Rational(ref n1), &Number::Fixnum(n2)) => (&**n1).eq(&n2),
-            (&Number::Fixnum(_), &Number::Float(OrderedFloat(_))) => false,
-            (&Number::Float(OrderedFloat(_)), &Number::Fixnum(_)) => false,
+            (&Number::Fixnum(n1), &Number::Float(n2)) => OrderedFloat(n1 as f64).eq(&n2),
+            (&Number::Float(n1), &Number::Fixnum(n2)) => n1.eq(&OrderedFloat(n2 as f64)),
             (&Number::Integer(ref n1), &Number::Integer(ref n2)) => n1.eq(n2),
-            (&Number::Integer(_), Number::Float(_)) => false,
-            (&Number::Float(_), &Number::Integer(_)) => false,
-            (&Number::Integer(_), &Number::Rational(_)) => false,
-            (&Number::Rational(_), &Number::Integer(_)) => false,
-            (&Number::Rational(_), Number::Float(_)) => false,
-            (&Number::Float(_), &Number::Rational(_)) => false,
+            (&Number::Integer(ref n1), Number::Float(n2)) => OrderedFloat(n1.to_f64()).eq(&n2),
+            (&Number::Float(n1), &Number::Integer(ref n2)) => n1.eq(&OrderedFloat(n2.to_f64())),
+            (&Number::Integer(ref n1), &Number::Rational(ref n2)) => {
+                #[cfg(feature = "num")]
+                {
+                    &Rational::from(&**n1) == &**n2
+                }
+                #[cfg(not(feature = "num"))]
+                {
+                    &**n1 == &**n2
+                }
+            }
+            (&Number::Rational(ref n1), &Number::Integer(ref n2)) => {
+                #[cfg(feature = "num")]
+                {
+                    &**n1 == &Rational::from(&**n2)
+                }
+                #[cfg(not(feature = "num"))]
+                {
+                    &**n1 == &**n2
+                }
+            }
+            (&Number::Rational(ref n1), &Number::Float(n2)) => OrderedFloat(n1.to_f64()).eq(&n2),
+            (&Number::Float(n1), &Number::Rational(ref n2)) => n1.eq(&OrderedFloat(n2.to_f64())),
             (&Number::Float(f1), &Number::Float(f2)) => f1.eq(&f2),
             (&Number::Rational(ref r1), &Number::Rational(ref r2)) => r1.eq(&r2),
         }
@@ -663,15 +689,33 @@ impl Ord for Number {
             (Number::Integer(n1), &Number::Fixnum(n2)) => (&**n1).cmp(&Integer::from(n2)),
             (&Number::Fixnum(n1), Number::Rational(n2)) => Rational::from(n1).cmp(&*n2),
             (Number::Rational(n1), &Number::Fixnum(n2)) => (&**n1).cmp(&Rational::from(n2)),
-            (&Number::Fixnum(_), &Number::Float(OrderedFloat(_))) => Ordering::Greater,
-            (&Number::Float(OrderedFloat(_)), &Number::Fixnum(_)) => Ordering::Less,
+            (&Number::Fixnum(n1), &Number::Float(n2)) => OrderedFloat(n1 as f64).cmp(&n2),
+            (&Number::Float(n1), &Number::Fixnum(n2)) => n1.cmp(&OrderedFloat(n2 as f64)),
             (&Number::Integer(ref n1), &Number::Integer(ref n2)) => n1.cmp(n2),
-            (&Number::Integer(_), Number::Float(_)) => Ordering::Greater,
-            (&Number::Float(_), &Number::Integer(_)) => Ordering::Less,
-            (&Number::Integer(_), &Number::Rational(_)) => Ordering::Greater,
-            (&Number::Rational(_), &Number::Integer(_)) => Ordering::Less,
-            (&Number::Rational(_), Number::Float(_)) => Ordering::Greater,
-            (&Number::Float(_), &Number::Rational(_)) => Ordering::Less,
+            (&Number::Integer(ref n1), Number::Float(n2)) => OrderedFloat(n1.to_f64()).cmp(&n2),
+            (&Number::Float(n1), &Number::Integer(ref n2)) => n1.cmp(&OrderedFloat(n2.to_f64())),
+            (&Number::Integer(ref n1), &Number::Rational(ref n2)) => {
+                #[cfg(feature = "num")]
+                {
+                    Rational::from(&**n1).cmp(n2)
+                }
+                #[cfg(not(feature = "num"))]
+                {
+                    (&**n1).partial_cmp(&**n2).unwrap_or(Ordering::Less)
+                }
+            }
+            (&Number::Rational(ref n1), &Number::Integer(ref n2)) => {
+                #[cfg(feature = "num")]
+                {
+                    (&**n1).cmp(&Rational::from(&**n2))
+                }
+                #[cfg(not(feature = "num"))]
+                {
+                    (&**n1).partial_cmp(&**n2).unwrap_or(Ordering::Less)
+                }
+            }
+            (&Number::Rational(ref n1), &Number::Float(n2)) => OrderedFloat(n1.to_f64()).cmp(&n2),
+            (&Number::Float(n1), &Number::Rational(ref n2)) => n1.cmp(&OrderedFloat(n2.to_f64())),
             (&Number::Float(f1), &Number::Float(f2)) => f1.cmp(&f2),
             (&Number::Rational(ref r1), &Number::Rational(ref r2)) => r1.cmp(&r2),
         }
@@ -683,9 +727,6 @@ impl<'a> TryFrom<(Addr, &'a Heap)> for Number {
 
     fn try_from((addr, heap): (Addr, &'a Heap)) -> Result<Number, Self::Error> {
         match addr {
-            Addr::CharCode(c) => {
-                Ok(Number::from(c as isize))
-            }
             Addr::Fixnum(n) => {
                 Ok(Number::from(n))
             }
@@ -716,9 +757,6 @@ impl<'a> TryFrom<&'a HeapCellValue> for Number {
         match value {
             HeapCellValue::Addr(addr) => {
                 match addr {
-                    &Addr::CharCode(c) => {
-                        Ok(Number::from(c as isize))
-                    }
                     &Addr::Fixnum(n) => {
                         Ok(Number::from(n))
                     }
@@ -750,6 +788,13 @@ impl<'a> TryFrom<&'a HeapCellValue> for Number {
     }
 }
 
+impl<'a> From<&'a Integer> for Number {
+    #[inline]
+    fn from(src: &'a Integer) -> Self {
+        Number::Integer(Rc::new(Integer::from(src)))
+    }
+}
+
 // Computes n ^ power. Ignores the sign of power.
 pub fn binary_pow(mut n: Integer, power: &Integer) -> Integer {
     let mut power = Integer::from(power.abs_ref());

src/clause_types.rs

@@ -1,14 +1,14 @@
-use prolog_parser::ast::*;
+use crate::prolog_parser::ast::*;
 
-use crate::prolog::forms::Number;
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::rug::rand::RandState;
+use crate::forms::Number;
+use crate::machine::machine_indices::*;
+use crate::rug::rand::RandState;
 
-use ref_thread_local::RefThreadLocal;
+use crate::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,
@@ -158,16 +158,29 @@ pub enum SystemClauseType {
     BindFromRegister,
     CallContinuation,
     CharCode,
+    CharType,
     CharsToNumber,
     ClearAttributeGoals,
     CloneAttributeGoals,
     CodesToNumber,
     CopyTermWithoutAttrVars,
     CheckCutPoint,
+    Close,
     CopyToLiftedHeap,
     CreatePartialString,
+    CurrentHostname,
     CurrentInput,
     CurrentOutput,
+    DirectoryFiles,
+    FileSize,
+    FileExists,
+    DirectoryExists,
+    DirectorySeparator,
+    MakeDirectory,
+    DeleteFile,
+    WorkingDirectory,
+    PathCanonical,
+    FileTime,
     DeleteAttribute,
     DeleteHeadAttribute,
     DynamicModuleResolution(usize),
@@ -177,7 +190,13 @@ pub enum SystemClauseType {
     ExpandTerm,
     FetchGlobalVar,
     FetchGlobalVarWithOffset,
+    FirstStream,
+    FlushOutput,
+    GetByte,
     GetChar,
+    GetNChars,
+    GetCode,
+    GetSingleChar,
     ResetAttrVarState,
     TruncateIfNoLiftedHeapGrowthDiff,
     TruncateIfNoLiftedHeapGrowth,
@@ -212,8 +231,17 @@ pub enum SystemClauseType {
     NumberToChars,
     NumberToCodes,
     OpDeclaration,
+    Open,
+    NextStream,
     PartialStringTail,
+    PeekByte,
+    PeekChar,
+    PeekCode,
     PointsToContinuationResetMarker,
+    PutByte,
+    PutChar,
+    PutChars,
+    PutCode,
     REPL(REPLCodePtr),
     ReadQueryTerm,
     ReadTerm,
@@ -230,6 +258,8 @@ pub enum SystemClauseType {
     SetOutput,
     StoreGlobalVar,
     StoreGlobalVarWithOffset,
+    StreamProperty,
+    SetStreamPosition,
     InferenceLevel,
     CleanUpBlock,
     EraseBall,
@@ -240,8 +270,9 @@ pub enum SystemClauseType {
     GetDoubleQuotes,
     InstallNewBlock,
     Maybe,
+    CpuNow,
+    CurrentTime,
     QuotedToken,
-    RawInputReadChar,
     ReadTermFromChars,
     ResetBlock,
     ReturnFromVerifyAttr,
@@ -250,7 +281,13 @@ pub enum SystemClauseType {
     SetDoubleQuotes,
     SetSeed,
     SkipMaxList,
+    Sleep,
+    SocketClientOpen,
+    SocketServerOpen,
+    SocketServerAccept,
+    SocketServerClose,
     Succeed,
+    TermAttributedVariables,
     TermVariables,
     TruncateLiftedHeapTo,
     UnifyWithOccursCheck,
@@ -260,6 +297,25 @@ pub enum SystemClauseType {
     WAMInstructions,
     WriteTerm,
     WriteTermToChars,
+    ScryerPrologVersion,
+    CryptoRandomByte,
+    CryptoDataHash,
+    CryptoDataHKDF,
+    CryptoPasswordHash,
+    CryptoDataEncrypt,
+    CryptoDataDecrypt,
+    CryptoCurveScalarMult,
+    Ed25519Sign,
+    Ed25519Verify,
+    Ed25519NewKeyPair,
+    Ed25519KeyPairPublicKey,
+    Curve25519ScalarMult,
+    LoadHTML,
+    LoadXML,
+    GetEnv,
+    SetEnv,
+    UnsetEnv,
+    CharsBase64,
 }
 
 impl SystemClauseType {
@@ -276,6 +332,7 @@ impl SystemClauseType {
             &SystemClauseType::BindFromRegister => clause_name!("$bind_from_register"),
             &SystemClauseType::CallContinuation => clause_name!("$call_continuation"),
             &SystemClauseType::CharCode => clause_name!("$char_code"),
+            &SystemClauseType::CharType => clause_name!("$char_type"),
             &SystemClauseType::CharsToNumber => clause_name!("$chars_to_number"),
             &SystemClauseType::CheckCutPoint => clause_name!("$check_cp"),
             &SystemClauseType::ClearAttributeGoals => clause_name!("$clear_attribute_goals"),
@@ -284,18 +341,30 @@ impl SystemClauseType {
             &SystemClauseType::CopyTermWithoutAttrVars => clause_name!("$copy_term_without_attr_vars"),
             &SystemClauseType::CreatePartialString => clause_name!("$create_partial_string"),
             &SystemClauseType::CurrentInput => clause_name!("$current_input"),
+            &SystemClauseType::CurrentHostname => clause_name!("$current_hostname"),
             &SystemClauseType::CurrentOutput => clause_name!("$current_output"),
+            &SystemClauseType::DirectoryFiles => clause_name!("$directory_files"),
+            &SystemClauseType::FileSize => clause_name!("$file_size"),
+            &SystemClauseType::FileExists => clause_name!("$file_exists"),
+            &SystemClauseType::DirectoryExists => clause_name!("$directory_exists"),
+            &SystemClauseType::DirectorySeparator => clause_name!("$directory_separator"),
+            &SystemClauseType::MakeDirectory => clause_name!("$make_directory"),
+            &SystemClauseType::DeleteFile => clause_name!("$delete_file"),
+            &SystemClauseType::WorkingDirectory => clause_name!("$working_directory"),
+            &SystemClauseType::PathCanonical => clause_name!("$path_canonical"),
+            &SystemClauseType::FileTime => clause_name!("$file_time"),
             &SystemClauseType::REPL(REPLCodePtr::CompileBatch) => clause_name!("$compile_batch"),
-	        &SystemClauseType::REPL(REPLCodePtr::UseModule) => clause_name!("$use_module"),
-	        &SystemClauseType::REPL(REPLCodePtr::UseQualifiedModule) => {
-		        clause_name!("$use_qualified_module")
-	        }
-	        &SystemClauseType::REPL(REPLCodePtr::UseModuleFromFile) => {
-		        clause_name!("$use_module_from_file")
-	        }
-	        &SystemClauseType::REPL(REPLCodePtr::UseQualifiedModuleFromFile) => {
-		        clause_name!("$use_qualified_module_from_file")
-	        }
+            &SystemClauseType::REPL(REPLCodePtr::UseModule) => clause_name!("$use_module"),
+            &SystemClauseType::REPL(REPLCodePtr::UseQualifiedModule) => {
+                    clause_name!("$use_qualified_module")
+            }
+            &SystemClauseType::REPL(REPLCodePtr::UseModuleFromFile) => {
+                    clause_name!("$use_module_from_file")
+            }
+            &SystemClauseType::REPL(REPLCodePtr::UseQualifiedModuleFromFile) => {
+                    clause_name!("$use_qualified_module_from_file")
+            }
+            &SystemClauseType::Close => clause_name!("$close"),
             &SystemClauseType::CopyToLiftedHeap => clause_name!("$copy_to_lh"),
             &SystemClauseType::DeleteAttribute => clause_name!("$del_attr_non_head"),
             &SystemClauseType::DeleteHeadAttribute => clause_name!("$del_attr_head"),
@@ -308,7 +377,13 @@ impl SystemClauseType {
             &SystemClauseType::FetchGlobalVarWithOffset => {
                 clause_name!("$fetch_global_var_with_offset")
             }
+            &SystemClauseType::FirstStream => clause_name!("$first_stream"),
+            &SystemClauseType::FlushOutput => clause_name!("$flush_output"),
+            &SystemClauseType::GetByte => clause_name!("$get_byte"),
             &SystemClauseType::GetChar => clause_name!("$get_char"),
+            &SystemClauseType::GetNChars => clause_name!("$get_n_chars"),
+            &SystemClauseType::GetCode => clause_name!("$get_code"),
+            &SystemClauseType::GetSingleChar => clause_name!("$get_single_char"),
             &SystemClauseType::ResetAttrVarState => clause_name!("$reset_attr_var_state"),
             &SystemClauseType::TruncateIfNoLiftedHeapGrowth => {
                 clause_name!("$truncate_if_no_lh_growth")
@@ -337,15 +412,21 @@ impl SystemClauseType {
             &SystemClauseType::GetSCCCleaner => clause_name!("$get_scc_cleaner"),
             &SystemClauseType::Halt => clause_name!("$halt"),
             &SystemClauseType::HeadIsDynamic => clause_name!("$head_is_dynamic"),
-            &SystemClauseType::OpDeclaration => clause_name!("$op$"),
+            &SystemClauseType::Open => clause_name!("$open"),
+            &SystemClauseType::OpDeclaration => clause_name!("$op"),
             &SystemClauseType::InstallSCCCleaner => clause_name!("$install_scc_cleaner"),
             &SystemClauseType::InstallInferenceCounter => {
                 clause_name!("$install_inference_counter")
             }
             &SystemClauseType::IsPartialString => clause_name!("$is_partial_string"),
             &SystemClauseType::PartialStringTail => clause_name!("$partial_string_tail"),
+            &SystemClauseType::PeekByte => clause_name!("$peek_byte"),
+            &SystemClauseType::PeekChar => clause_name!("$peek_char"),
+            &SystemClauseType::PeekCode => clause_name!("$peek_code"),
             &SystemClauseType::LiftedHeapLength => clause_name!("$lh_length"),
             &SystemClauseType::Maybe => clause_name!("maybe"),
+            &SystemClauseType::CpuNow => clause_name!("$cpu_now"),
+            &SystemClauseType::CurrentTime => clause_name!("$current_time"),
             &SystemClauseType::ModuleAssertDynamicPredicateToFront => {
                 clause_name!("$module_asserta")
             }
@@ -355,16 +436,28 @@ impl SystemClauseType {
             &SystemClauseType::ModuleHeadIsDynamic => clause_name!("$module_head_is_dynamic"),
             &SystemClauseType::ModuleExists => clause_name!("$module_exists"),
             &SystemClauseType::ModuleOf => clause_name!("$module_of"),
+            &SystemClauseType::NextStream => clause_name!("$next_stream"),
             &SystemClauseType::NoSuchPredicate => clause_name!("$no_such_predicate"),
             &SystemClauseType::NumberToChars => clause_name!("$number_to_chars"),
             &SystemClauseType::NumberToCodes => clause_name!("$number_to_codes"),
             &SystemClauseType::PointsToContinuationResetMarker => {
                 clause_name!("$points_to_cont_reset_marker")
             }
+            &SystemClauseType::PutByte => {
+                clause_name!("$put_byte")
+            }
+            &SystemClauseType::PutChar => {
+                clause_name!("$put_char")
+            }
+            &SystemClauseType::PutChars => {
+                clause_name!("$put_chars")
+            }
+            &SystemClauseType::PutCode => {
+                clause_name!("$put_code")
+            }
             &SystemClauseType::QuotedToken => {
                 clause_name!("$quoted_token")
             }
-            &SystemClauseType::RawInputReadChar => clause_name!("$raw_input_read_char"),
             &SystemClauseType::RedoAttrVarBinding => clause_name!("$redo_attr_var_binding"),
             &SystemClauseType::RemoveCallPolicyCheck => clause_name!("$remove_call_policy_check"),
             &SystemClauseType::RemoveInferenceCounter => clause_name!("$remove_inference_counter"),
@@ -373,6 +466,8 @@ impl SystemClauseType {
             &SystemClauseType::SetInput => clause_name!("$set_input"),
             &SystemClauseType::SetOutput => clause_name!("$set_output"),
             &SystemClauseType::SetSeed => clause_name!("$set_seed"),
+            &SystemClauseType::StreamProperty => clause_name!("$stream_property"),
+            &SystemClauseType::SetStreamPosition => clause_name!("$set_stream_position"),
             &SystemClauseType::StoreGlobalVar => clause_name!("$store_global_var"),
             &SystemClauseType::StoreGlobalVarWithOffset => {
                 clause_name!("$store_global_var_with_offset")
@@ -400,7 +495,13 @@ impl SystemClauseType {
             &SystemClauseType::SetCutPointByDefault(_) => clause_name!("$set_cp_by_default"),
             &SystemClauseType::SetDoubleQuotes => clause_name!("$set_double_quotes"),
             &SystemClauseType::SkipMaxList => clause_name!("$skip_max_list"),
+            &SystemClauseType::Sleep => clause_name!("$sleep"),
+            &SystemClauseType::SocketClientOpen => clause_name!("$socket_client_open"),
+            &SystemClauseType::SocketServerOpen => clause_name!("$socket_server_open"),
+            &SystemClauseType::SocketServerAccept => clause_name!("$socket_server_accept"),
+            &SystemClauseType::SocketServerClose => clause_name!("$socket_server_close"),
             &SystemClauseType::Succeed => clause_name!("$succeed"),
+            &SystemClauseType::TermAttributedVariables => clause_name!("$term_attributed_variables"),
             &SystemClauseType::TermVariables => clause_name!("$term_variables"),
             &SystemClauseType::TruncateLiftedHeapTo => clause_name!("$truncate_lh_to"),
             &SystemClauseType::UnifyWithOccursCheck => clause_name!("$unify_with_occurs_check"),
@@ -410,6 +511,25 @@ impl SystemClauseType {
             &SystemClauseType::WAMInstructions => clause_name!("$wam_instructions"),
             &SystemClauseType::WriteTerm => clause_name!("$write_term"),
             &SystemClauseType::WriteTermToChars => clause_name!("$write_term_to_chars"),
+            &SystemClauseType::ScryerPrologVersion => clause_name!("$scryer_prolog_version"),
+            &SystemClauseType::CryptoRandomByte => clause_name!("$crypto_random_byte"),
+            &SystemClauseType::CryptoDataHash => clause_name!("$crypto_data_hash"),
+            &SystemClauseType::CryptoDataHKDF => clause_name!("$crypto_data_hkdf"),
+            &SystemClauseType::CryptoPasswordHash => clause_name!("$crypto_password_hash"),
+            &SystemClauseType::CryptoDataEncrypt => clause_name!("$crypto_data_encrypt"),
+            &SystemClauseType::CryptoDataDecrypt => clause_name!("$crypto_data_decrypt"),
+            &SystemClauseType::CryptoCurveScalarMult => clause_name!("$crypto_curve_scalar_mult"),
+            &SystemClauseType::Ed25519Sign => clause_name!("$ed25519_sign"),
+            &SystemClauseType::Ed25519Verify => clause_name!("$ed25519_verify"),
+            &SystemClauseType::Ed25519NewKeyPair => clause_name!("$ed25519_new_keypair"),
+            &SystemClauseType::Ed25519KeyPairPublicKey => clause_name!("$ed25519_keypair_public_key"),
+            &SystemClauseType::Curve25519ScalarMult => clause_name!("$curve25519_scalar_mult"),
+            &SystemClauseType::LoadHTML => clause_name!("$load_html"),
+            &SystemClauseType::LoadXML => clause_name!("$load_xml"),
+            &SystemClauseType::GetEnv => clause_name!("$getenv"),
+            &SystemClauseType::SetEnv => clause_name!("$setenv"),
+            &SystemClauseType::UnsetEnv => clause_name!("$unsetenv"),
+            &SystemClauseType::CharsBase64 => clause_name!("$chars_base64"),
         }
     }
 
@@ -428,6 +548,7 @@ impl SystemClauseType {
             ("$assertz", 4) => Some(SystemClauseType::AssertDynamicPredicateToBack),
             ("$call_continuation", 1) => Some(SystemClauseType::CallContinuation),
             ("$char_code", 2) => Some(SystemClauseType::CharCode),
+            ("$char_type", 2) => Some(SystemClauseType::CharType),
             ("$chars_to_number", 2) => Some(SystemClauseType::CharsToNumber),
             ("$clear_attribute_goals", 0) => Some(SystemClauseType::ClearAttributeGoals),
             ("$clone_attribute_goals", 1) => Some(SystemClauseType::CloneAttributeGoals),
@@ -437,8 +558,13 @@ impl SystemClauseType {
             ("$check_cp", 1) => Some(SystemClauseType::CheckCutPoint),
             ("$compile_batch", 0) => Some(SystemClauseType::REPL(REPLCodePtr::CompileBatch)),
             ("$copy_to_lh", 2) => Some(SystemClauseType::CopyToLiftedHeap),
+            ("$close", 2) => Some(SystemClauseType::Close),
+            ("$current_hostname", 1) => Some(SystemClauseType::CurrentHostname),
             ("$current_input", 1) => Some(SystemClauseType::CurrentInput),
             ("$current_output", 1) => Some(SystemClauseType::CurrentOutput),
+            ("$first_stream", 1) => Some(SystemClauseType::FirstStream),
+            ("$next_stream", 2) => Some(SystemClauseType::NextStream),
+            ("$flush_output", 1) => Some(SystemClauseType::FlushOutput),
             ("$del_attr_non_head", 1) => Some(SystemClauseType::DeleteAttribute),
             ("$del_attr_head", 1) => Some(SystemClauseType::DeleteHeadAttribute),
             ("$get_next_db_ref", 2) => Some(SystemClauseType::GetNextDBRef),
@@ -449,15 +575,34 @@ impl SystemClauseType {
             ("$enqueue_attribute_goal", 1) => Some(SystemClauseType::EnqueueAttributeGoal),
             ("$enqueue_attr_var", 1) => Some(SystemClauseType::EnqueueAttributedVar),
             ("$partial_string_tail", 2) => Some(SystemClauseType::PartialStringTail),
+            ("$peek_byte", 2) => Some(SystemClauseType::PeekByte),
+            ("$peek_char", 2) => Some(SystemClauseType::PeekChar),
+            ("$peek_code", 2) => Some(SystemClauseType::PeekCode),
             ("$is_partial_string", 1) => Some(SystemClauseType::IsPartialString),
             ("$expand_term", 2) => Some(SystemClauseType::ExpandTerm),
             ("$expand_goal", 2) => Some(SystemClauseType::ExpandGoal),
             ("$fetch_global_var", 2) => Some(SystemClauseType::FetchGlobalVar),
             ("$fetch_global_var_with_offset", 3) => Some(SystemClauseType::FetchGlobalVarWithOffset),
-            ("$get_char", 1) => Some(SystemClauseType::GetChar),
+            ("$get_byte", 2) => Some(SystemClauseType::GetByte),
+            ("$get_char", 2) => Some(SystemClauseType::GetChar),
+            ("$get_n_chars", 3) => Some(SystemClauseType::GetNChars),
+            ("$get_code", 2) => Some(SystemClauseType::GetCode),
+            ("$get_single_char", 1) => Some(SystemClauseType::GetSingleChar),
             ("$points_to_cont_reset_marker", 1) => {
                 Some(SystemClauseType::PointsToContinuationResetMarker)
             }
+            ("$put_byte", 2) => {
+                Some(SystemClauseType::PutByte)
+            }
+            ("$put_char", 2) => {
+                Some(SystemClauseType::PutChar)
+            }
+            ("$put_chars", 2) => {
+                Some(SystemClauseType::PutChars)
+            }
+            ("$put_code", 2) => {
+                Some(SystemClauseType::PutCode)
+            }
             ("$reset_attr_var_state", 0) => Some(SystemClauseType::ResetAttrVarState),
             ("$truncate_if_no_lh_growth", 1) => {
                 Some(SystemClauseType::TruncateIfNoLiftedHeapGrowth)
@@ -473,12 +618,14 @@ impl SystemClauseType {
             ("$get_lh_from_offset_diff", 3) => Some(SystemClauseType::GetLiftedHeapFromOffsetDiff),
             ("$get_double_quotes", 1) => Some(SystemClauseType::GetDoubleQuotes),
             ("$get_scc_cleaner", 1) => Some(SystemClauseType::GetSCCCleaner),
-            ("$halt", 0) => Some(SystemClauseType::Halt),
+            ("$halt", 1) => Some(SystemClauseType::Halt),
             ("$head_is_dynamic", 1) => Some(SystemClauseType::HeadIsDynamic),
             ("$install_scc_cleaner", 2) => Some(SystemClauseType::InstallSCCCleaner),
             ("$install_inference_counter", 3) => Some(SystemClauseType::InstallInferenceCounter),
             ("$lh_length", 1) => Some(SystemClauseType::LiftedHeapLength),
             ("$maybe", 0) => Some(SystemClauseType::Maybe),
+            ("$cpu_now", 1) => Some(SystemClauseType::CpuNow),
+            ("$current_time", 1) => Some(SystemClauseType::CurrentTime),
             ("$module_exists", 1) => Some(SystemClauseType::ModuleExists),
             ("$module_of", 2) => Some(SystemClauseType::ModuleOf),
             ("$module_retract_clause", 5) => Some(SystemClauseType::ModuleRetractClause),
@@ -487,6 +634,7 @@ impl SystemClauseType {
             ("$number_to_chars", 2) => Some(SystemClauseType::NumberToChars),
             ("$number_to_codes", 2) => Some(SystemClauseType::NumberToCodes),
             ("$op", 3) => Some(SystemClauseType::OpDeclaration),
+            ("$open", 7) => Some(SystemClauseType::Open),
             ("$redo_attr_var_binding", 2) => Some(SystemClauseType::RedoAttrVarBinding),
             ("$remove_call_policy_check", 1) => Some(SystemClauseType::RemoveCallPolicyCheck),
             ("$remove_inference_counter", 2) => Some(SystemClauseType::RemoveInferenceCounter),
@@ -494,6 +642,8 @@ impl SystemClauseType {
             ("$set_cp", 1) => Some(SystemClauseType::SetCutPoint(temp_v!(1))),
             ("$set_input", 1) => Some(SystemClauseType::SetInput),
             ("$set_output", 1) => Some(SystemClauseType::SetOutput),
+            ("$stream_property", 3) => Some(SystemClauseType::StreamProperty),
+            ("$set_stream_position", 2) => Some(SystemClauseType::SetStreamPosition),
             ("$inference_level", 2) => Some(SystemClauseType::InferenceLevel),
             ("$clean_up_block", 1) => Some(SystemClauseType::CleanUpBlock),
             ("$erase_ball", 0) => Some(SystemClauseType::EraseBall),
@@ -506,10 +656,9 @@ impl SystemClauseType {
             ("$get_cp", 1) => Some(SystemClauseType::GetCutPoint),
             ("$install_new_block", 1) => Some(SystemClauseType::InstallNewBlock),
             ("$quoted_token", 1) => Some(SystemClauseType::QuotedToken),
-            ("$raw_input_read_char", 1) => Some(SystemClauseType::RawInputReadChar),
             ("$nextEP", 3) => Some(SystemClauseType::NextEP),
-            ("$read_query_term", 2) => Some(SystemClauseType::ReadQueryTerm),
-            ("$read_term", 2) => Some(SystemClauseType::ReadTerm),
+            ("$read_query_term", 5) => Some(SystemClauseType::ReadQueryTerm),
+            ("$read_term", 5) => Some(SystemClauseType::ReadTerm),
             ("$read_term_from_chars", 2) => Some(SystemClauseType::ReadTermFromChars),
             ("$reset_block", 1) => Some(SystemClauseType::ResetBlock),
             ("$reset_cont_marker", 0) => Some(SystemClauseType::ResetContinuationMarker),
@@ -522,30 +671,65 @@ impl SystemClauseType {
             ("$set_double_quotes", 1) => Some(SystemClauseType::SetDoubleQuotes),
             ("$set_seed", 1) => Some(SystemClauseType::SetSeed),
             ("$skip_max_list", 4) => Some(SystemClauseType::SkipMaxList),
+            ("$sleep", 1) => Some(SystemClauseType::Sleep),
+            ("$socket_client_open", 8) => Some(SystemClauseType::SocketClientOpen),
+            ("$socket_server_open", 3) => Some(SystemClauseType::SocketServerOpen),
+            ("$socket_server_accept", 7) => Some(SystemClauseType::SocketServerAccept),
+            ("$socket_server_close", 1) => Some(SystemClauseType::SocketServerClose),
             ("$store_global_var", 2) => Some(SystemClauseType::StoreGlobalVar),
             ("$store_global_var_with_offset", 2) => Some(SystemClauseType::StoreGlobalVarWithOffset),
+            ("$term_attributed_variables", 2) => Some(SystemClauseType::TermAttributedVariables),
             ("$term_variables", 2) => Some(SystemClauseType::TermVariables),
             ("$truncate_lh_to", 1) => Some(SystemClauseType::TruncateLiftedHeapTo),
             ("$unwind_environments", 0) => Some(SystemClauseType::UnwindEnvironments),
             ("$unwind_stack", 0) => Some(SystemClauseType::UnwindStack),
             ("$unify_with_occurs_check", 2) => Some(SystemClauseType::UnifyWithOccursCheck),
-	        ("$use_module", 1) => Some(SystemClauseType::REPL(REPLCodePtr::UseModule)),
-	        ("$use_module_from_file", 1) =>
-		        Some(SystemClauseType::REPL(REPLCodePtr::UseModuleFromFile)),
-	        ("$use_qualified_module", 2) =>
-		        Some(SystemClauseType::REPL(REPLCodePtr::UseQualifiedModule)),
-	        ("$use_qualified_module_from_file", 2) =>
-		        Some(SystemClauseType::REPL(REPLCodePtr::UseQualifiedModuleFromFile)),
+            ("$directory_files", 2) => Some(SystemClauseType::DirectoryFiles),
+            ("$file_size", 2) => Some(SystemClauseType::FileSize),
+            ("$file_exists", 1) => Some(SystemClauseType::FileExists),
+            ("$directory_exists", 1) => Some(SystemClauseType::DirectoryExists),
+            ("$directory_separator", 1) => Some(SystemClauseType::DirectorySeparator),
+            ("$make_directory", 1) => Some(SystemClauseType::MakeDirectory),
+            ("$delete_file", 1) => Some(SystemClauseType::DeleteFile),
+            ("$working_directory", 2) => Some(SystemClauseType::WorkingDirectory),
+            ("$path_canonical", 2) => Some(SystemClauseType::PathCanonical),
+            ("$file_time", 3) => Some(SystemClauseType::FileTime),
+            ("$use_module", 1) => Some(SystemClauseType::REPL(REPLCodePtr::UseModule)),
+            ("$use_module_from_file", 1) =>
+                    Some(SystemClauseType::REPL(REPLCodePtr::UseModuleFromFile)),
+            ("$use_qualified_module", 2) =>
+                    Some(SystemClauseType::REPL(REPLCodePtr::UseQualifiedModule)),
+            ("$use_qualified_module_from_file", 2) =>
+                    Some(SystemClauseType::REPL(REPLCodePtr::UseQualifiedModuleFromFile)),
             ("$variant", 2) => Some(SystemClauseType::Variant),
             ("$wam_instructions", 3) => Some(SystemClauseType::WAMInstructions),
-            ("$write_term", 6) => Some(SystemClauseType::WriteTerm),
+            ("$write_term", 7) => Some(SystemClauseType::WriteTerm),
             ("$write_term_to_chars", 7) => Some(SystemClauseType::WriteTermToChars),
+            ("$scryer_prolog_version", 1) => Some(SystemClauseType::ScryerPrologVersion),
+            ("$crypto_random_byte", 1) => Some(SystemClauseType::CryptoRandomByte),
+            ("$crypto_data_hash", 4) => Some(SystemClauseType::CryptoDataHash),
+            ("$crypto_data_hkdf", 7) => Some(SystemClauseType::CryptoDataHKDF),
+            ("$crypto_password_hash", 4) => Some(SystemClauseType::CryptoPasswordHash),
+            ("$crypto_data_encrypt", 6) => Some(SystemClauseType::CryptoDataEncrypt),
+            ("$crypto_data_decrypt", 6) => Some(SystemClauseType::CryptoDataDecrypt),
+            ("$crypto_curve_scalar_mult", 5) => Some(SystemClauseType::CryptoCurveScalarMult),
+            ("$ed25519_sign", 5) => Some(SystemClauseType::Ed25519Sign),
+            ("$ed25519_verify", 5) => Some(SystemClauseType::Ed25519Verify),
+            ("$ed25519_new_keypair", 1) => Some(SystemClauseType::Ed25519NewKeyPair),
+            ("$ed25519_keypair_public_key", 3) => Some(SystemClauseType::Ed25519KeyPairPublicKey),
+            ("$curve25519_scalar_mult", 3) => Some(SystemClauseType::Curve25519ScalarMult),
+            ("$load_html", 3) => Some(SystemClauseType::LoadHTML),
+            ("$load_xml", 3) => Some(SystemClauseType::LoadXML),
+            ("$getenv", 2) => Some(SystemClauseType::GetEnv),
+            ("$setenv", 2) => Some(SystemClauseType::SetEnv),
+            ("$unsetenv", 1) => Some(SystemClauseType::UnsetEnv),
+            ("$chars_base64", 4) => Some(SystemClauseType::CharsBase64),
             _ => None,
         }
     }
 }
 
-#[derive(Clone, Eq, PartialEq)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub enum BuiltInClauseType {
     AcyclicTerm,
     Arg,
@@ -563,7 +747,7 @@ pub enum BuiltInClauseType {
     Sort,
 }
 
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ClauseType {
     BuiltIn(BuiltInClauseType),
     CallN,

src/codegen.rs

@@ -1,28 +1,30 @@
-use prolog_parser::ast::*;
+use crate::prolog_parser::ast::*;
 
-use crate::prolog::allocator::*;
-use crate::prolog::arithmetic::*;
-use crate::prolog::clause_types::*;
-use crate::prolog::fixtures::*;
-use crate::prolog::forms::*;
-use crate::prolog::indexing::*;
-use crate::prolog::instructions::*;
-use crate::prolog::iterators::*;
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::targets::*;
+use crate::allocator::*;
+use crate::arithmetic::*;
+use crate::clause_types::*;
+use crate::fixtures::*;
+use crate::forms::*;
+use crate::indexing::*;
+use crate::instructions::*;
+use crate::iterators::*;
+use crate::machine::machine_indices::*;
+use crate::targets::*;
 
-use indexmap::{IndexMap, IndexSet};
+use crate::indexmap::{IndexMap, IndexSet};
 
 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,
@@ -120,31 +122,45 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
         *self.var_count.get(var).unwrap()
     }
 
+    fn mark_var_in_non_callable(
+        &mut self,
+        name: Rc<Var>,
+        term_loc: GenContext,
+        vr: &'a Cell<VarReg>,
+        code: &mut Code,
+    ) -> RegType {
+        let mut target = Vec::new();
+        self.marker.mark_var(name, Level::Shallow, vr, term_loc, &mut target);
+
+        if !target.is_empty() {
+            code.extend(target.into_iter().map(Line::Query));
+        }
+
+        vr.get().norm()
+    }
+
     fn mark_non_callable(
         &mut self,
         name: Rc<Var>,
-        arity: usize,
+        arg: usize,
         term_loc: GenContext,
         vr: &'a Cell<VarReg>,
         code: &mut Code,
     ) -> RegType {
         match self.marker.bindings().get(&name) {
-            Some(&VarData::Temp(_, t, _)) if t != 0 => RegType::Temp(t),
-            Some(&VarData::Perm(p)) if p != 0 => RegType::Perm(p),
-            _ => {
-                let mut target = Vec::new();
-
-                self.marker.reset_arg(arity);
-                self.marker
-                    .mark_var(name, Level::Shallow, vr, term_loc, &mut target);
-
-                if !target.is_empty() {
-                    for query_instr in target {
-                        code.push(Line::Query(query_instr));
-                    }
+            Some(&VarData::Temp(_, t, _)) if t != 0 => {
+                RegType::Temp(t)
+            }
+            Some(&VarData::Perm(p)) if p != 0 => {
+                if let GenContext::Last(_) = term_loc {
+                    self.mark_var_in_non_callable(name.clone(), term_loc, vr, code);
+                    temp_v!(arg)
+                } else {
+                    RegType::Perm(p)
                 }
-
-                vr.get().norm()
+            }
+            _ => {
+                self.mark_var_in_non_callable(name, term_loc, vr, code)
             }
         }
     }
@@ -341,7 +357,9 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                 &mut ControlInstruction::CallClause(_, _, _, ref mut last_call, _) => {
                     *last_call = true
                 }
-                &mut ControlInstruction::JmpBy(_, _, _, ref mut last_call) => *last_call = true,
+                &mut ControlInstruction::JmpBy(_, _, _, ref mut last_call) => {
+                    *last_call = true
+                }
                 &mut ControlInstruction::Proceed => {}
                 _ => dealloc_index += 1,
             },
@@ -361,33 +379,42 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
     ) -> Result<(), ParserError> {
         match ct {
             &InlinedClauseType::CompareNumber(cmp, ..) => {
-                if let &Term::Var(ref vr, ref name) = terms[0].as_ref() {
-                    self.mark_non_callable(name.clone(), 2, term_loc, vr, code);
-                }
-
-                if let &Term::Var(ref vr, ref name) = terms[1].as_ref() {
-                    self.mark_non_callable(name.clone(), 2, term_loc, vr, code);
-                }
+                self.marker.reset_arg(2);
 
                 let (mut lcode, at_1) = self.call_arith_eval(terms[0].as_ref(), 1)?;
                 let (mut rcode, at_2) = self.call_arith_eval(terms[1].as_ref(), 2)?;
 
+                let at_1 =
+                    if let &Term::Var(ref vr, ref name) = terms[0].as_ref() {
+                        ArithmeticTerm::Reg(
+                            self.mark_non_callable(name.clone(), 1, term_loc, vr, code)
+                        )
+                    } else {
+                        at_1.unwrap_or(interm!(1))
+                    };
+
+                let at_2 =
+                    if let &Term::Var(ref vr, ref name) = terms[1].as_ref() {
+                        ArithmeticTerm::Reg(
+                            self.mark_non_callable(name.clone(), 2, term_loc, vr, code)
+                        )
+                    } else {
+                        at_2.unwrap_or(interm!(2))
+                    };
+
                 code.append(&mut lcode);
                 code.append(&mut rcode);
 
-                code.push(compare_number_instr!(
-                    cmp,
-                    at_1.unwrap_or(interm!(1)),
-                    at_2.unwrap_or(interm!(2))
-                ));
+                code.push(compare_number_instr!(cmp, at_1, at_2));
             }
             &InlinedClauseType::IsAtom(..) => match terms[0].as_ref() {
-                &Term::Constant(_, Constant::Char(_))
-                | &Term::Constant(_, Constant::EmptyList)
-                | &Term::Constant(_, Constant::Atom(..)) => {
+                &Term::Constant(_, Constant::Char(_)) |
+                &Term::Constant(_, Constant::EmptyList) |
+                &Term::Constant(_, Constant::Atom(..)) => {
                     code.push(succeed!());
                 }
                 &Term::Var(ref vr, ref name) => {
+                    self.marker.reset_arg(1);
                     let r = self.mark_non_callable(name.clone(), 1, term_loc, vr, code);
                     code.push(is_atom!(r));
                 }
@@ -403,6 +430,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                     code.push(succeed!());
                 }
                 &Term::Var(ref vr, ref name) => {
+                    self.marker.reset_arg(1);
                     let r = self.mark_non_callable(name.clone(), 1, term_loc, vr, code);
                     code.push(is_atomic!(r));
                 }
@@ -412,6 +440,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                     code.push(succeed!());
                 }
                 &Term::Var(ref vr, ref name) => {
+                    self.marker.reset_arg(1);
                     let r = self.mark_non_callable(name.clone(), 1, term_loc, vr, code);
                     code.push(is_compound!(r));
                 }
@@ -424,6 +453,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                     code.push(succeed!());
                 }
                 &Term::Var(ref vr, ref name) => {
+                    self.marker.reset_arg(1);
                     let r = self.mark_non_callable(name.clone(), 1, term_loc, vr, code);
                     code.push(is_rational!(r));
                 }
@@ -436,6 +466,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                     code.push(succeed!());
                 }
                 &Term::Var(ref vr, ref name) => {
+                    self.marker.reset_arg(1);
                     let r = self.mark_non_callable(name.clone(), 1, term_loc, vr, code);
                     code.push(is_float!(r));
                 }
@@ -448,6 +479,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                     code.push(fail!());
                 }
                 &Term::Var(ref vr, ref name) => {
+                    self.marker.reset_arg(1);
                     let r = self.mark_non_callable(name.clone(), 1, term_loc, vr, code);
                     code.push(is_nonvar!(r));
                 }
@@ -461,6 +493,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                     code.push(succeed!());
                 }
                 &Term::Var(ref vr, ref name) => {
+                    self.marker.reset_arg(1);
                     let r = self.mark_non_callable(name.clone(), 1, term_loc, vr, code);
                     code.push(is_integer!(r));
                 }
@@ -476,6 +509,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                     code.push(succeed!());
                 }
                 &Term::Var(ref vr, ref name) => {
+                    self.marker.reset_arg(1);
                     let r = self.mark_non_callable(name.clone(), 1, term_loc, vr, code);
                     code.push(is_var!(r));
                 }
@@ -490,7 +524,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
         term: &'a Term,
         target_int: usize,
     ) -> Result<ArithCont, ArithmeticError> {
-        let mut evaluator = ArithmeticEvaluator::new(self.marker.bindings(), target_int);
+        let mut evaluator = ArithmeticEvaluator::new(&self.marker.bindings(), target_int);
         evaluator.eval(term)
     }
 
@@ -504,23 +538,17 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
         let (mut acode, at) = self.call_arith_eval(terms[1].as_ref(), 1)?;
         code.append(&mut acode);
 
-        Ok(match terms[0].as_ref() {
+        self.marker.reset_arg(2);
+
+        match terms[0].as_ref() {
             &Term::Var(ref vr, ref name) => {
                 let mut target = vec![];
 
-                self.marker.reset_arg(2);
-                self.marker
-                    .mark_var(name.clone(), Level::Shallow, vr, term_loc, &mut target);
+                self.marker.mark_var(name.clone(), Level::Shallow, vr, term_loc, &mut target);
 
                 if !target.is_empty() {
                     code.extend(target.into_iter().map(Line::Query));
                 }
-
-                if use_default_call_policy {
-                    code.push(is_call_by_default!(temp_v!(1), at.unwrap_or(interm!(1))))
-                } else {
-                    code.push(is_call!(temp_v!(1), at.unwrap_or(interm!(1))))
-                }
             }
             &Term::Constant(_, ref c @ Constant::Integer(_)) |
             &Term::Constant(_, ref c @ Constant::Fixnum(_)) => {
@@ -530,11 +558,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                     temp_v!(1)
                 )));
 
-                if use_default_call_policy {
-                    code.push(is_call_by_default!(temp_v!(1), at.unwrap_or(interm!(1))))
-                } else {
-                    code.push(is_call!(temp_v!(1), at.unwrap_or(interm!(1))))
-                }
+                self.marker.advance_arg();
             }
             &Term::Constant(_, ref c @ Constant::Float(_)) => {
                 code.push(Line::Query(put_constant!(
@@ -543,11 +567,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                     temp_v!(1)
                 )));
 
-                if use_default_call_policy {
-                    code.push(is_call_by_default!(temp_v!(1), at.unwrap_or(interm!(1))))
-                } else {
-                    code.push(is_call!(temp_v!(1), at.unwrap_or(interm!(1))))
-                }
+                self.marker.advance_arg();
             }
             &Term::Constant(_, ref c @ Constant::Rational(_)) => {
                 code.push(Line::Query(put_constant!(
@@ -556,13 +576,27 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                     temp_v!(1)
                 )));
 
-                if use_default_call_policy {
-                    code.push(is_call_by_default!(temp_v!(1), at.unwrap_or(interm!(1))))
-                } else {
-                    code.push(is_call!(temp_v!(1), at.unwrap_or(interm!(1))))
-                }
+                self.marker.advance_arg();
             }
-            _ => code.push(fail!()),
+            _ => {
+                code.push(fail!());
+                return Ok(());
+            }
+        }
+
+        let at =
+            if let &Term::Var(ref vr, ref name) = terms[1].as_ref() {
+                ArithmeticTerm::Reg(
+                    self.mark_non_callable(name.clone(), 2, term_loc, vr, code)
+                )
+            } else {
+                at.unwrap_or(interm!(1))
+            };
+
+        Ok(if use_default_call_policy {
+            code.push(is_call_by_default!(temp_v!(1), at));
+        } else {
+            code.push(is_call!(temp_v!(1), at));
         })
     }
 

src/debray_allocator.rs

@@ -1,17 +1,18 @@
-use indexmap::IndexMap;
+use crate::indexmap::IndexMap;
 
-use prolog_parser::ast::*;
+use crate::prolog_parser::ast::*;
 
-use crate::prolog::allocator::*;
-use crate::prolog::fixtures::*;
-use crate::prolog::forms::*;
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::targets::*;
+use crate::allocator::*;
+use crate::fixtures::*;
+use crate::forms::*;
+use crate::machine::machine_indices::*;
+use crate::targets::*;
 
 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,
@@ -292,7 +293,9 @@ impl<'a> Allocator<'a> for DebrayAllocator {
 
                 (pr, true)
             }
-            r => (r, false),
+            r => {
+                (r, false)
+            }
         };
 
         self.mark_reserved_var(var, lvl, cell, term_loc, target, r, is_new_var);

src/examples/bimetatrans/README.md

@@ -0,0 +1,219 @@
+### BiMetaTrans 1.0
+
+BiMetaTrans(Prolog, RuleML) is a bidirectional translator capable of
+parsing and generating a well-formed sublanguage of RuleML/XML to/from
+a metalogical encoding of our own design called Prolog/'$V'. For later
+ease of reference:
+
+* Prolog/'$V' stands for "Metalogic Prolog with variable-as-'$V'-term encoding"
+* RuleML/XML stands for "RuleML in XML with any kind of rendering"
+* RuleML/xmL stands for "RuleML in minified XML"
+* RuleML/Xml stands for "RuleML in indented XML"
+
+"Minified XML" refers to XML with only necessary whitespace, between
+element names and attributes, and pairs of attributes, with all
+indentation stripped out. "Indented XML" contains indentation and
+newlines, and is usually formatted for human readers.
+
+The specification of Prolog/'$V', and of the NafHornlogEq sublanguage
+of RuleML/XML targeted by BiMetaTrans, is contained in the preprint
+[Invertible Bidirectional Metalogical Translation Between Prolog and
+RuleML/XML for Knowledge Representation and
+Querying](http://ruleml.org/papers/RuleMLXMLBiDirTransScryer.pdf) and
+its accompanying talk
+[slides](http://ruleml.org/talks/RuleMLXMLBiDirTransScryer-talk.pdf). The
+preprint and talk also describe the implementation of BiMetaTrans
+found here, and outlines a strategy for proving the invertibility of
+BiMetaTrans.
+
+BiMetaTrans exports a single public predicate subsuming its user
+API, `parse_ruleml/3`. It has two modes, each corresponding to a single
+direction of translation:
+
+```
+parse_ruleml(+AssertItems, +QueryItems, ?XML)    (Prolog->RuleML)
+parse_ruleml(?AssertItems, ?QueryItems, +XML)    (RuleML->Prolog)
+```
+
+The modes constrain the inputs to fit one of two patterns, the
+first where AssertItems and QueryItems are instantiated and XML is
+possibly a variable, and conversely for the second. Instantiated
+inputs are expected to be ground, meaning they should not contain
+free variables.
+
+We explore several examples of its use in Scryer Prolog.
+
+Loading BiMetaTrans from the Scryer REPL:
+
+```
+?- use_module('src/examples/bimetatrans/bimetatrans').
+```
+
+Using `write/1` to print the string to standard output, capturing the
+`Prolog->RuleML` direction (`write/1` is used because it does not
+print strings with escape characters, ie., `\"` for double quote):
+
+```
+?- parse_ruleml([people('Alex',male),people('Alex',female),people('Siri',female)], [], XML),
+   write(XML).
+"<Assert mapClosure="universal"><Atom><Rel>people</Rel><Ind>Alex</Ind><Data iso:type="symbol">male</Data></Atom><Atom><Rel>people</Rel><Ind>Alex</Ind><Data iso:type="symbol">female</Data></Atom><Atom><Rel>people</Rel><Ind>Siri</Ind><Data iso:type="symbol">female</Data></Atom></Assert>"   XML = "<Assert mapClosure= ...".
+```
+
+Note that the XML input can contain extraneous whitespace and
+indentation while generated XML never does (ie., the XML generated by
+BiMetaTrans is always Ruleml/xmL). `\` is used to continue ISO Prolog
+strings to the next line but is never stored to the string by the
+Prolog reader.
+
+Performing the inverse translation of the previous example
+(`RuleML->Prolog`), in RuleML/Xml:
+
+```
+?- parse_ruleml(AssertItems, QueryItems,
+                "<Assert mapClosure=\"universal\">\
+                   <Atom>\
+                           <Rel>people</Rel>\
+                           <Ind>Alex</Ind>\
+                           <Data iso:type=\"symbol\">male</Data>\
+                   </Atom>\
+                   <Atom>\
+                           <Rel>people</Rel>\
+                           <Ind>Alex</Ind>\
+                           <Data iso:type=\"symbol\">female</Data>\
+                   </Atom>\
+                   <Atom>\
+                           <Rel>people</Rel>\
+                           <Ind>Siri</Ind>\
+                           <Data iso:type=\"symbol\">female</Data>\
+                   </Atom>\
+                </Assert>").
+   AssertItems = [people('Alex',male),people('Alex',female),people('Siri',female)], QueryItems = [].
+```
+
+Double quote characters within strings must be escaped as in
+`\"`. Non-empty AssertItems and QueryItems lists generated to
+RuleML/xmL simultaneously:
+
+```
+?- parse_ruleml([a(item), b(item), c(item)], [(?- p, q, r(1), s(-2.222342432), t("attached")), (?- u, v('$V'(q)))], XML),
+   write(XML).
+"<Assert mapClosure="universal"><Atom><Rel>a</Rel><Data iso:type="symbol">item</Data></Atom><Atom><Rel>b</Rel><Data iso:type="symbol">item</Data></Atom><Atom><Rel>c</Rel><Data iso:type="symbol">item</Data></Atom></Assert><Query closure="existential"><And><Atom><Rel>p</Rel></Atom><Atom><Rel>q</Rel></Atom><Atom><Rel>r</Rel><Data iso:type="number">1</Data></Atom><Atom><Rel>s</Rel><Data iso:type="number">-2.222342432</Data></Atom><Atom><Rel>t</Rel><Data iso:type="string">"attached"</Data></Atom></And></Query><Query closure="existential"><And><Atom><Rel>u</Rel></Atom><Atom><Rel>v</Rel><Var>q</Var></Atom></And></Query>"   XML = "<Assert mapClosure= ...".
+```
+
+To insert escape characters into the printed RuleML/xmL, we use
+`writeq/1` in place of `write/1`:
+
+```
+?- parse_ruleml([a(item), b(item), c(item)], [(?- p, q, r(1), s(-2.222342432), t("attached")), (?- u, v('$V'(q)))], XML),
+   writeq(XML).
+"<Assert mapClosure=\"universal\"><Atom><Rel>a</Rel><Data iso:type=\"symbol\">item</Data></Atom><Atom><Rel>b</Rel><Data iso:type=\"symbol\">item</Data></Atom><Atom><Rel>c</Rel><Data iso:type=\"symbol\">item</Data></Atom></Assert><Query closure=\"existential\"><And><Atom><Rel>p</Rel></Atom><Atom><Rel>q</Rel></Atom><Atom><Rel>r</Rel><Data iso:type=\"number\">1</Data></Atom><Atom><Rel>s</Rel><Data iso:type=\"number\">-2.222342432</Data></Atom><Atom><Rel>t</Rel><Data iso:type=\"string\">\"attached\"</Data></Atom></And></Query><Query closure=\"existential\"><And><Atom><Rel>u</Rel></Atom><Atom><Rel>v</Rel><Var>q</Var></Atom></And></Query>"   XML = "<Assert mapClosure= ...".
+```
+
+XML can be pretty printed using a [free online XML pretty
+printer](https://codebeautify.org/xmlviewer), as here:
+
+```
+<Assert mapClosure=\"universal\">
+	<Atom>
+		<Rel>a</Rel>
+		<Data iso:type=\"symbol\">item</Data>
+	</Atom>
+	<Atom>
+		<Rel>b</Rel>
+		<Data iso:type=\"symbol\">item</Data>
+	</Atom>
+	<Atom>
+		<Rel>c</Rel>
+		<Data iso:type=\"symbol\">item</Data>
+	</Atom>
+</Assert>
+<Query closure=\"existential\">
+	<And>
+		<Atom>
+			<Rel>p</Rel>
+		</Atom>
+		<Atom>
+			<Rel>q</Rel>
+		</Atom>
+		<Atom>
+			<Rel>r</Rel>
+			<Data iso:type=\"number\">1</Data>
+		</Atom>
+		<Atom>
+			<Rel>s</Rel>
+			<Data iso:type=\"number\">-2.222342432</Data>
+		</Atom>
+		<Atom>
+			<Rel>t</Rel>
+			<Data iso:type=\"string\">\"attached\"</Data>
+		</Atom>
+	</And>
+</Query>
+<Query closure=\"existential\">
+	<And>
+		<Atom>
+			<Rel>u</Rel>
+		</Atom>
+		<Atom>
+			<Rel>v</Rel>
+			<Var>q</Var>
+		</Atom>
+	</And>
+</Query>
+```
+
+The AssertItems and QueryItems lists can then be recovered using this
+RuleML/Xml string, with the `\` character added to the end of each
+line:
+
+```
+?- parse_ruleml(AssertItems, QueryItems,
+                "<Assert mapClosure=\"universal\">\
+                    <Atom>\
+                        <Rel>a</Rel>\
+                        <Data iso:type=\"symbol\">item</Data>\
+                    </Atom>\
+                    <Atom>\
+                        <Rel>b</Rel>\
+                        <Data iso:type=\"symbol\">item</Data>\
+                    </Atom>\
+                    <Atom>\
+                        <Rel>c</Rel>\
+                        <Data iso:type=\"symbol\">item</Data>\
+                    </Atom>\
+                </Assert>\
+                <Query closure=\"existential\">\
+                    <And>\
+                        <Atom>\
+                            <Rel>p</Rel>\
+                        </Atom>\
+                        <Atom>\
+                            <Rel>q</Rel>\
+                        </Atom>\
+                        <Atom>\
+                            <Rel>r</Rel>\
+                            <Data iso:type=\"number\">1</Data>\
+                        </Atom>\
+                        <Atom>\
+                            <Rel>s</Rel>\
+                            <Data iso:type=\"number\">-2.222342432</Data>\
+                        </Atom>\
+                        <Atom>\
+                            <Rel>t</Rel>\
+                            <Data iso:type=\"string\">\"attached\"</Data>\
+                        </Atom>\
+                    </And>\
+                </Query>\
+                <Query closure=\"existential\">\
+                    <And>\
+                        <Atom>\
+                            <Rel>u</Rel>\
+                        </Atom>\
+                        <Atom>\
+                            <Rel>v</Rel>\
+                            <Var>q</Var>\
+                        </Atom>\
+                    </And>\
+                </Query>").
+   AssertItems = [a(item),b(item),c(item)], QueryItems = [(?-p,q,r(1),s(-2.222342432),t("attached")),(?-u,v('$V'(q)))].
+```

src/examples/bimetatrans/bimetatrans.pl

@@ -1,6 +1,8 @@
-:- module(ruleml_xml_parser, [parse_ruleml/3]).
+:- module(bimetatrans, [parse_ruleml/3]).
 
 :- use_module(library(dcgs)).
+:- use_module(library(iso_ext)).
+:- use_module(library(lists)).
 
 :- set_prolog_flag(double_quotes, chars).
 
@@ -17,28 +19,34 @@
  * all indentation stripped out. "Indented XML" contains indentation
  * and newlines, and is usually formatted for human readers.
  *
- * parse_ruleml/3 is the sole public predicate of BiMetaTrans(RuleML,
- * Prolog), a bidirectional translator capable of parsing well-formed
+ * parse_ruleml/3 is the sole public predicate of BiMetaTrans(Prolog,
+ * RuleML), a bidirectional translator capable of parsing well-formed
  * RuleML/XML (valid w.r.t. a proposed anchor schema nafhornlogeq
  * defining a sublanguage of the existing anchor schema naffologeq) to
  * an equivalent Prolog/'$V' term and back to RuleML/xmL. It has the
  * modes
  *
- * +AssertItem, +QueryItems, ?XML    (Prolog->RuleML)
- * ?AssertItem, ?QueryItems, +XML    (RuleML->Prolog)
+ * +AssertItems, +QueryItems, ?XML    (Prolog->RuleML)
+ * ?AssertItems, ?QueryItems, +XML    (RuleML->Prolog)
  *
  * The modes constrain the inputs to fit one of two patterns, the
- * first where AssertItem and QueryItem are instantiated and XML is
+ * first where AssertItems and QueryItems are instantiated and XML is
  * possibly a variable, and conversely for the second. Instantiated
  * inputs are expected to be ground, meaning they should not contain
  * free variables.
  *
+ * A RuleML/XML document is assumed to contain an optional Assert
+ * element (with zero or more children) and zero or more Query
+ * elements. The children of the Assert element are the Items of
+ * AssertItems, while the Items of QueryItems each correspond to a
+ * single Query element.
+ *
  * parse_ruleml/3 is meant to subsume an invertible function in the
  * sense that the top-level query
  *
- * ?- parse_ruleml(AssertItem, QueryItems, XML0),    % Prolog->RuleML
- *    parse_ruleml(AssertItem0, QueryItems0, XML),   % RuleML->Prolog
- *    AssertItem0 == AssertItem,                     % Test for expected round-trip results.
+ * ?- parse_ruleml(AssertItems, QueryItems, XML0),    % Prolog->RuleML
+ *    parse_ruleml(AssertItems0, QueryItems0, XML),   % RuleML->Prolog
+ *    AssertItems0 == AssertItems,                    % Test for expected round-trip results.
  *    QueryItems0 == QueryItems,
  *    XML0 == XML.
  *
@@ -46,10 +54,11 @@
  * not 0-appended are instantiated and therefore ground.
  */
 
-parse_ruleml(AssertItem, QueryItem, XML) :-
-    (  ( var(AssertItem) ; var(QueryItem) ), var(XML) ->
+parse_ruleml(AssertItems, QueryItems, XML) :-
+    (  ( var(AssertItems) ; var(QueryItems) ), var(XML) ->
        throw(error(instantiation_error, parse_ruleml/2))
-    ;  phrase(ruleml_top_level_items(AssertItem, QueryItem), XML)
+    ;  phrase(ruleml_top_level_items(AssertItems, QueryItems), XML),
+       !
     ).
 
 
@@ -80,24 +89,15 @@ parse_header -->
  *
  * The two arguments are (un)instantiated depending on the direction
  * in which parse_ruleml/2 operates. In either direction, once
- * ruleml_query_item(QueryItems) or ruleml_assert(AssertItem)
- * succeeds:
- *
- * 1) AssertItem/QueryItems is a fully ground list of terms,
- * corresponding to an Assert/Query performative of the RuleML/XML KB.
- *
- * 2) It would not be meaningful to backtrack after the last success,
- * thus undoing its effects; that is because we have already refuted
- * the possibility of there being further items for the grammar to
- * consume. Hence we see that the cut (!) does not restrict the
- * generality of the grammar.
+ * ruleml_query_item(QueryItems) or ruleml_assert(AssertItems)
+ * succeeds, AssertItems and QueryItems are ground lists of terms,
+ * corresponding to Assert/Query performative(s) of the RuleML/XML KB.
  */
 
-ruleml_top_level_items(AssertItem, QueryItems) -->
-    (  ruleml_assert(AssertItem),
-       ruleml_query_items(QueryItems),
-       !
-    ;  { AssertItem = [] },
+ruleml_top_level_items(AssertItems, QueryItems) -->
+    (  ruleml_assert(AssertItems),
+       ruleml_query_items(QueryItems)
+    ;  { AssertItems = [] },
        ruleml_query_items(QueryItems)
     ).
 
@@ -167,22 +167,16 @@ ruleml_top_level_items(AssertItem, QueryItems) -->
  * outset of ruleml_assert//1 will cause it to fail, meaning that
  * an empty <Assert></Assert> element is never emitted to the output
  * RuleML/xmL.
- *
- * The two cuts are green cuts, meaning they do not change the meaning
- * or output of the program, they simply prevent needless
- * backtracking.
  */
 
 ruleml_assert(Items) -->
     (  { var(Items) } ->
        list_ws("<Assert mapClosure=\"universal\">"),
        ruleml_assert_items(Items),
-       !,
        list_ws("</Assert>")
     ;  "<Assert mapClosure=\"universal\">",
        { Items \== [] },
        ruleml_assert_items(Items),
-       !,
        "</Assert>"
     ).
 
@@ -204,7 +198,6 @@ ruleml_assert(Items) -->
 
 ruleml_assert_items([Item | Items]) -->
     ruleml_assert_item(Item),
-    !,
     ruleml_assert_items(Items).
 ruleml_assert_items([]) --> [].
 
@@ -212,7 +205,6 @@ ruleml_assert_items([]) --> [].
 ruleml_query_items(Items) -->
     (  { var(Items) } ->
        ruleml_query_item(Item),
-       !,
        (  { var(Item) } ->
           ruleml_query_items(Items)
        ;  { Items = [Item | Items0] },
@@ -220,7 +212,6 @@ ruleml_query_items(Items) -->
        )
     ;  { Items = [Item | Items0] },
        ruleml_query_item(Item),
-       !,
        ruleml_query_items(Items0)
     ).
 ruleml_query_items([]) --> [].
@@ -277,7 +268,7 @@ space(' ') --> " ".
 
 decimal_point('.') --> ".".
 
-sign('-') --> "-", !.
+sign('-') --> "-".
 sign('+') --> "+".
 
 double_quote('"') --> "\"".
@@ -330,7 +321,6 @@ ruleml_condition(Item) -->
 
 ruleml_item_conjunction([Item | Items]) -->
     ruleml_condition(Item),
-    !,
     ruleml_item_conjunction(Items).
 ruleml_item_conjunction([]) --> [].
 
@@ -402,7 +392,6 @@ ruleml_conjunction_of_items(Items) -->
 
 ruleml_item_disjunction([Item | Items]) -->
     ruleml_condition(Item),
-    !,
     ruleml_item_disjunction(Items).
 ruleml_item_disjunction([]) --> [].
 
@@ -498,7 +487,7 @@ ruleml_plex(Plex) -->
           list_ws("</Plex>")
        ;  list_ws("<Plex/>")
        )
-    ;  {  \+ string(Plex),
+    ;  {  ( \+ partial_string(Plex) ; Plex == [] ),
           acyclic_term(Plex) },
        (  {  functor(Plex, ('.'), 2) } ->
           {  split_plex(Plex, PlexItems, RepoVar) },
@@ -547,7 +536,6 @@ ruleml_naf(Item) -->
 
 ruleml_atoms([Item|Items]) -->
     ruleml_atom(Item),
-    !,
     ruleml_atoms(Items).
 ruleml_atoms([]) --> [].
 
@@ -582,13 +570,11 @@ ruleml_atom(Item) -->
        list_ws("<Atom>"),
        list_ws("<Rel>"),
        prolog_symbol(Name),
-       { Name \== (','), Name \== (';') },
        list_ws("</Rel>"),
        ruleml_items(Args),
        list_ws("</Atom>"),
        { Item =.. [Name | Args] }
     ;  { Item =.. [Name | Args] },
-       { Name \== (','), Name \== (';') },
        "<Atom>",
        "<Rel>",
        prolog_symbol(Name),
@@ -652,7 +638,6 @@ ruleml_expr(Item) -->
        (  list_ws("<repo>"),
           ruleml_item(RepoItem),
           list_ws("</repo>"),
-          !,
           { fold_commas(Args, ArgsCommas) },
           { Item =.. [Name, (ArgsCommas | RepoItem)] }
        ;  { Item =.. [Name | Args] }
@@ -789,7 +774,7 @@ constant_chars(symbol, Constant, Chars) :-
 
 /*
  * ruleml_data//1 delegates to ruleml_data_contents//2 to determine
- * the contents of <Data> nodes, with adjoining xsi:type elements.
+ * the contents of <Data> nodes, with adjoining iso:type elements.
  *
  * constant_chars/3 performs type-driven conversion between
  * Prolog/'$V' and RuleML/XML in both directions;
@@ -799,13 +784,13 @@ constant_chars(symbol, Constant, Chars) :-
 
 ruleml_data(Name) -->
     (  { var(Name) } ->
-       list_ws("<Data xsi:type=\""),
+       list_ws("<Data iso:type=\""),
        prolog_symbol(Type),
        list_ws("\">"),
        ruleml_data_contents(Type, Cs),
        { constant_chars(Type, Name, Cs) },
        list_ws("</Data>")
-    ;  "<Data xsi:type=\"",
+    ;  "<Data iso:type=\"",
        { constant_chars(Type, Name, Cs) },
        prolog_symbol(Type),
        "\">",
@@ -823,15 +808,12 @@ ruleml_data(Name) -->
  * converting from lists of characters (here denoted as Cs) to the
  * named data type in ISO Prolog. The type information is given
  * in the first argument.
- *
- * Grammatically, ruleml_data_contents//3 is a disjoint union of its
- * subgrammars, justifying the cut at the end of the first two rules.
  */
 
 ruleml_data_contents(number, Cs) -->
-    ruleml_number(Cs), !.
+    ruleml_number(Cs).
 ruleml_data_contents(symbol, Cs) -->
-    ruleml_symbol(Cs), !.
+    ruleml_symbol(Cs).
 ruleml_data_contents(string, Cs) -->
     ruleml_string(Cs).
 
@@ -1195,8 +1177,7 @@ fold_semicolons(List, Output) :-
  * complicated by Scryer's current lack of multi-argument indexing.
  */
 
-fold_list([Item], _, Item) :-
-    !.
+fold_list([Item], _, Item).
 fold_list([Item|Items], F, Form) :-
     Form =.. [F, Item, Fs],
     fold_list(Items, F, Fs).

src/examples/domain.pl

@@ -22,7 +22,6 @@ verify_attributes(Var, Other, Goals) :-
                 (   Els = [] ->             % exactly one element
                     Goals = [Other=El]      % implied binding
                 ;   Goals = [],
-		    put_atts(Other, -dom(_)),
                     put_atts(Other, dom(Dc))% rescue intersection
                 )
             ;   Goals = [],

src/examples/echo_server.pl

@@ -0,0 +1,31 @@
+:- module(echo_server, [echo_server/0,
+                        echo_server/1]).
+
+:- use_module(library(format)).
+:- use_module(library(sockets)).
+
+
+echo_server :-
+    echo_server('127.0.0.1').
+
+
+echo_server(Addr) :-
+    socket_server_open(Addr:Port, ServerSocket),
+    format("echo_server: connection opened at ~w:~d~n", [Addr, Port]),
+    socket_server_accept(ServerSocket, Client, Stream, [eof_action(eof_code)]),
+    format("echo_server: connection accepted from ~a~n", [Client]),
+    !,
+    echo_loop(Stream),
+    socket_server_close(ServerSocket).
+
+
+echo_loop(Stream) :-
+    read_term(Stream, Term, []),
+    (  Term == end_of_file ->
+       true
+    ;
+       format("received: ~w~n", [Term]),
+       !,
+       echo_loop(Stream)
+    ).
+

src/examples/least_time.pl

@@ -11,11 +11,12 @@
  */
 
 :- module(least_time, [find_min_time/2,
-		       write_time_nl/1]).
+		               write_time_nl/1]).
 
 
 :- use_module(library(dcgs)).
 :- use_module(library(format)).
+:- use_module(library(lists)).
 :- use_module(library(reif)).
 
 
@@ -30,12 +31,12 @@ valid_time([H1,H2,M1,M2], T) :-
     memberd_t(H2, [0,1,2,3,4,5,6,7,8,9], TH2),
     memberd_t(M1, [0,1,2,3,4,5], TM1),
     memberd_t(M2, [0,1,2,3,4,5,6,7,8,9], TM2),
-    (  maplist(=(true), [TH1, TH2, TM1, TM2]) ->       
+    (  maplist(=(true), [TH1, TH2, TM1, TM2]) ->
        (  H1 =:= 2 ->
-	  (  H2 =< 3 ->
-	     T = true
-	  ;  T = false
-	  )
+	      (  H2 =< 3 ->
+	         T = true
+	      ;  T = false
+	      )
        ;  T = true
        )
     ;  T = false
@@ -49,15 +50,7 @@ permuted_times(Time, PermutedTimes) :-
 
 find_min_time(Time, Min) :-
     valid_time(Time, true),
-    permuted_times(Time, PermutedTimes),
-    find_min_time_(PermutedTimes, Time, Min).
-
-find_min_time_([], Min, Min).
-find_min_time_([Time|Times], MinSoFar, Min) :-
-    (  Time @< MinSoFar ->
-       find_min_time_(Times, Time, Min)
-    ;  find_min_time_(Times, MinSoFar, Min)
-    ).
+    permuted_times(Time, [Min|_]).
 
 
 write_time_nl(Time) :-

src/examples/plres.pl

@@ -31,6 +31,7 @@
 
 :- use_module(library(dcgs)).
 :- use_module(library(dif)).
+:- use_module(library(format)).
 :- use_module(library(lists)).
 
 pl_resolution(Clauses0, Chain) :-

src/examples/utf8.pl

@@ -0,0 +1,31 @@
+:- use_module(library(charsio)).
+:- use_module(library(lists)).
+
+:- initialization(unit_test).
+
+unit_test :-
+  chars_utf8bytes("a£\x2124\", Bs),
+  Bs = [97, 194, 163, 226, 132, 164],
+  chars_utf8bytes(Cs, Bs),
+  Cs = "a£\x2124\".
+
+write_f :-
+  open('x.txt', write, Stream, [type(binary)]),
+  F = put_byte(Stream),
+  chars_utf8bytes("£\x2124\\x2764\\x1F496\\n", Bs),
+  maplist(F, Bs),
+  close(Stream).
+
+get_bytes(Stream, Res) :- get_bytes(Stream, [], Res).
+get_bytes(Stream, Acc, Res) :-
+  get_byte(Stream, B),
+  (B =:= -1 ->
+    reverse(Acc, Res)
+  ; get_bytes(Stream, [B|Acc], Res)).
+
+read_f :-
+  open('x.txt', read, Stream, [type(binary)]),
+  get_bytes(Stream, Bs),
+  chars_utf8bytes(Cs, Bs),
+  write(Cs),
+  close(Stream).

src/fixtures.rs

@@ -1,10 +1,10 @@
-use prolog_parser::ast::*;
+use crate::prolog_parser::ast::*;
 
-use crate::prolog::forms::*;
-use crate::prolog::instructions::*;
-use crate::prolog::iterators::*;
+use crate::forms::*;
+use crate::instructions::*;
+use crate::iterators::*;
 
-use indexmap::{IndexMap, IndexSet};
+use crate::indexmap::{IndexMap, IndexSet};
 
 use std::cell::Cell;
 use std::collections::BTreeSet;
@@ -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/forms.rs

@@ -1,18 +1,17 @@
-use prolog_parser::ast::*;
-use prolog_parser::parser::OpDesc;
-use prolog_parser::tabled_rc::*;
+use crate::prolog_parser::ast::*;
+use crate::prolog_parser::parser::OpDesc;
+use crate::prolog_parser::tabled_rc::*;
 
-use crate::prolog::clause_types::*;
-use crate::prolog::machine::machine_errors::*;
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::ordered_float::OrderedFloat;
-use crate::prolog::rug::{Integer, Rational};
+use crate::clause_types::*;
+use crate::machine::machine_errors::*;
+use crate::machine::machine_indices::*;
+use crate::ordered_float::OrderedFloat;
+use crate::rug::{Integer, Rational};
 
-use indexmap::IndexMap;
+use crate::indexmap::IndexMap;
 
 use std::cell::Cell;
 use std::collections::VecDeque;
-use std::convert::TryFrom;
 use std::path::PathBuf;
 use std::rc::Rc;
 
@@ -22,7 +21,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 +41,7 @@ impl TopLevel {
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum Level {
     Deep,
     Root,
@@ -58,7 +57,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 +85,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 +113,7 @@ impl Predicate {
     }
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum ListingSource {
     File(ClauseName, PathBuf), // filename, path
     User,
@@ -326,7 +325,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 +370,7 @@ impl PredicateClause {
     }
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum ModuleSource {
     Library(ClauseName),
     File(ClauseName),
@@ -392,13 +391,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 +432,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 {
@@ -506,11 +505,11 @@ pub fn fetch_atom_op_spec(
     spec: Option<SharedOpDesc>,
     op_dir: &OpDir,
 ) -> Option<SharedOpDesc> {
-    fetch_op_spec(name.clone(), 1, spec.clone(), op_dir)
-        .or_else(|| fetch_op_spec(name, 2, spec, op_dir))
+    fetch_op_spec_from_existing(name.clone(), 1, spec.clone(), op_dir)
+        .or_else(|| fetch_op_spec_from_existing(name, 2, spec, op_dir))
 }
 
-pub fn fetch_op_spec(
+pub fn fetch_op_spec_from_existing(
     name: ClauseName,
     arity: usize,
     spec: Option<SharedOpDesc>,
@@ -525,7 +524,15 @@ pub fn fetch_op_spec(
         }
     }
 
-    spec.or_else(|| match arity {
+    spec.or_else(|| fetch_op_spec(name, arity, op_dir))
+}
+
+pub fn fetch_op_spec(
+    name: ClauseName,
+    arity: usize,
+    op_dir: &OpDir,
+) -> Option<SharedOpDesc> {
+    match arity {
         2 => op_dir
             .get(&(name, Fixity::In))
             .and_then(|OpDirValue(spec, _)| {
@@ -543,7 +550,7 @@ pub fn fetch_op_spec(
             }
 
             op_dir
-                .get(&(name.clone(), Fixity::Post))
+                .get(&(name, Fixity::Post))
                 .and_then(|OpDirValue(spec, _)| {
                     if spec.prec() > 0 {
                         Some(spec.clone())
@@ -552,24 +559,27 @@ pub fn fetch_op_spec(
                     }
                 })
         }
-        _ => None,
-    })
+        _ => {
+            None
+        }
+    }
 }
 
 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 +597,7 @@ pub struct Module {
     pub listing_src: ListingSource,
  }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum Number {
     Float(OrderedFloat<f64>),
     Integer(Rc<Integer>),
@@ -648,21 +658,6 @@ impl Into<HeapCellValue> for Number {
 
 
 impl Number {
-    #[inline]
-    pub fn to_u32(&self) -> Option<u32> {
-        match self {
-            &Number::Fixnum(n) => u32::try_from(n).ok(),
-            &Number::Integer(ref n) => n.to_u32(),
-            &Number::Float(_) => None,
-            &Number::Rational(ref r) =>
-                if r.denom() == &1 {
-                    r.numer().to_u32()
-                } else {
-                    None
-                }
-        }
-    }
-
     #[inline]
     pub fn is_positive(&self) -> bool {
         match self {

src/heap_iter.rs

@@ -1,12 +1,13 @@
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::machine::machine_state::*;
+use crate::machine::machine_indices::*;
+use crate::machine::machine_state::*;
 
-use indexmap::IndexSet;
+use crate::indexmap::IndexSet;
 
 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>,
@@ -47,6 +48,9 @@ impl<'a> HCPreOrderIterator<'a> {
             HeapCellValue::Stream(_) => {
                 Addr::Stream(h)
             }
+            &HeapCellValue::TcpListener(_) => {
+                Addr::TcpListener(h)
+            }
         }
     }
 
@@ -89,21 +93,19 @@ impl<'a> HCPreOrderIterator<'a> {
             }
             Addr::Con(h) => {
                 if let &HeapCellValue::PartialString(ref pstr, has_tail) = &self.machine_st.heap[h] {
-                    if !self.machine_st.flags.double_quotes.is_atom() {
-                        return if let Some(c) = pstr.range_from(0 ..).next() {
-                            self.state_stack.push(Addr::PStrLocation(h, c.len_utf8()));
-                            self.state_stack.push(Addr::Char(c));
+                    if let Some(c) = pstr.range_from(0 ..).next() {
+                        self.state_stack.push(Addr::PStrLocation(h, c.len_utf8()));
+                        self.state_stack.push(Addr::Char(c));
 
-                            Addr::PStrLocation(h, 0)
-                        } else if has_tail {
-                            self.follow(Addr::HeapCell(h + 1))
-                        } else {
-                            Addr::EmptyList
-                        };
+                        Addr::PStrLocation(h, 0)
+                    } else if has_tail {
+                        self.follow(Addr::HeapCell(h + 1))
+                    } else {
+                        Addr::EmptyList
                     }
+                } else {
+                    Addr::Con(h)
                 }
-
-                Addr::Con(h)
             }
             da => {
                 da
@@ -120,12 +122,14 @@ impl<'a> Iterator for HCPreOrderIterator<'a> {
     }
 }
 
-pub trait MutStackHCIterator
-where Self: Iterator<Item = Addr>
+pub trait MutStackHCIterator<'b> where Self: Iterator
 {
-    fn stack(&mut self) -> &mut Vec<Addr>;
+    type MutStack;
+
+    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.
@@ -220,12 +224,15 @@ impl MachineState {
     }
 }
 
-impl<'a> MutStackHCIterator for HCPreOrderIterator<'a> {
-    fn stack(&mut self) -> &mut Vec<Addr> {
+impl<'b, 'a: 'b> MutStackHCIterator<'b> for HCPreOrderIterator<'a> {
+    type MutStack = &'b mut Vec<Addr>;
+
+    fn stack(&'b mut self) -> Self::MutStack {
         &mut self.state_stack
     }
 }
 
+#[derive(Debug)]
 pub struct HCAcyclicIterator<'a> {
     iter: HCPreOrderIterator<'a>,
     seen: IndexSet<Addr>,
@@ -248,6 +255,14 @@ impl<'a> Deref for HCAcyclicIterator<'a> {
     }
 }
 
+impl<'b, 'a: 'b> MutStackHCIterator<'b> for HCAcyclicIterator<'a> {
+    type MutStack = &'b mut Vec<Addr>;
+
+    fn stack(&'b mut self) -> Self::MutStack {
+        self.iter.stack()
+    }
+}
+
 impl<'a> Iterator for HCAcyclicIterator<'a>
 {
     type Item = Addr;
@@ -266,6 +281,7 @@ impl<'a> Iterator for HCAcyclicIterator<'a>
     }
 }
 
+#[derive(Debug)]
 pub struct HCZippedAcyclicIterator<'a> {
     i1: HCPreOrderIterator<'a>,
     i2: HCPreOrderIterator<'a>,
@@ -273,6 +289,14 @@ pub struct HCZippedAcyclicIterator<'a> {
     pub first_to_expire: Ordering,
 }
 
+impl<'b, 'a: 'b> MutStackHCIterator<'b> for HCZippedAcyclicIterator<'a> {
+    type MutStack = (&'b mut Vec<Addr>, &'b mut Vec<Addr>);
+
+    fn stack(&'b mut self) -> Self::MutStack {
+        (self.i1.stack(), self.i2.stack())
+    }
+}
+
 impl<'a> HCZippedAcyclicIterator<'a> {
     pub fn new(i1: HCPreOrderIterator<'a>, i2: HCPreOrderIterator<'a>) -> Self {
         HCZippedAcyclicIterator {
@@ -293,6 +317,7 @@ impl<'a> Iterator for HCZippedAcyclicIterator<'a>
             if !self.seen.contains(&(a1.clone(), a2.clone())) {
                 self.i1.stack().push(a1.clone());
                 self.i2.stack().push(a2.clone());
+
                 self.seen.insert((a1, a2));
 
                 break;

src/heap_print.rs

@@ -1,24 +1,26 @@
-use prolog_parser::ast::*;
+use crate::prolog_parser::ast::*;
 
-use crate::prolog::clause_types::*;
-use crate::prolog::forms::*;
-use crate::prolog::heap_iter::*;
-use crate::prolog::machine::heap::*;
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::machine::machine_state::*;
-use crate::prolog::ordered_float::OrderedFloat;
-use crate::prolog::rug::Integer;
+use crate::clause_types::*;
+use crate::forms::*;
+use crate::heap_iter::*;
+use crate::machine::heap::*;
+use crate::machine::machine_indices::*;
+use crate::machine::machine_state::*;
+use crate::machine::streams::*;
+use crate::ordered_float::OrderedFloat;
+use crate::rug::{Integer, Rational};
 
-use indexmap::{IndexMap, IndexSet};
+use crate::indexmap::{IndexMap, IndexSet};
 
 use std::cell::Cell;
 use std::convert::TryFrom;
 use std::iter::{FromIterator, once};
+use std::net::{IpAddr, TcpListener};
 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 +164,7 @@ fn char_to_string(is_quoted: bool, c: char) -> String {
     }
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 enum TokenOrRedirect {
     Atom(ClauseName),
     BarAsOp,
@@ -170,9 +172,12 @@ enum TokenOrRedirect {
     NumberedVar(String),
     CompositeRedirect(usize, DirectedOp),
     FunctorRedirect(usize),
+    IpAddr(IpAddr),
+    Number(Number, Option<DirectedOp>),
     Open,
     Close,
     Comma,
+    RawPtr(*const u8),
     Space,
     LeftCurly,
     RightCurly,
@@ -197,6 +202,7 @@ pub trait HCValueOutputter {
     fn range_from(&self, range: RangeFrom<usize>) -> &str;
 }
 
+#[derive(Debug)]
 pub struct PrinterOutputter {
     contents: String,
 }
@@ -335,6 +341,7 @@ impl MachineState {
 
 type ReverseHeapVarDict = IndexMap<Addr, Rc<Var>>;
 
+#[derive(Debug)]
 pub struct HCPrinter<'a, Outputter> {
     outputter: Outputter,
     machine_st: &'a MachineState,
@@ -449,9 +456,9 @@ fn non_quoted_token<Iter: Iterator<Item = char>>(mut iter: Iter) -> bool {
         } else if cut_char!(c) {
             iter.next().is_none()
         } else if c == '[' {
-            (iter.next() == Some(']') && iter.next().is_none())
+            iter.next() == Some(']') && iter.next().is_none()
         } else if c == '{' {
-            (iter.next() == Some('}') && iter.next().is_none())
+            iter.next() == Some('}') && iter.next().is_none()
         } else if solo_char!(c) {
             !(c == '(' || c == ')' || c == '}' || c == ']' || c == ',' || c == '%' || c == '|')
         } else {
@@ -638,8 +645,8 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
         }
 
         self.state_stack.pop();
-        self.state_stack.push(TokenOrRedirect::Open);
 
+        self.state_stack.push(TokenOrRedirect::Open);
         self.state_stack.push(TokenOrRedirect::Atom(name));
 
         true
@@ -959,6 +966,18 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
         });
     }
 
+    #[inline]
+    fn print_ip_addr(&mut self, ip: IpAddr) {
+        self.push_char('\'');
+        self.append_str(&format!("{}", ip));
+        self.push_char('\'');
+    }
+
+    #[inline]
+    fn print_raw_ptr(&mut self, ptr: *const u8) {
+        self.append_str(&format!("0x{:x}", ptr as usize));
+    }
+
     fn print_number(&mut self, n: Number, op: &Option<DirectedOp>) {
         let add_brackets = if let Some(op) = op {
             op.is_negative_sign() && n.is_positive()
@@ -985,6 +1004,10 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
                     });
                 }
             }
+            Number::Rational(r) => {
+                self.print_rational(&r, add_brackets);
+                return;
+            }
             n => {
                 let output_str = format!("{}", n);
 
@@ -999,6 +1022,71 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
         }
     }
 
+    fn print_rational(&mut self, r: &Rational, add_brackets: bool) {
+        match self.op_dir.get(&(clause_name!("rdiv"), Fixity::In)) {
+            Some(OpDirValue(ref spec, _)) => {
+                if add_brackets {
+                    self.state_stack.push(TokenOrRedirect::Close);
+                }
+
+                let rdiv_ct = clause_name!("rdiv");
+
+                let left_directed_op =
+                    if spec.prec() > 0 {
+                        Some(DirectedOp::Left(rdiv_ct.clone(), spec.clone()))
+                    } else {
+                        None
+                    };
+
+                let right_directed_op =
+                    if spec.prec() > 0 {
+                        Some(DirectedOp::Right(rdiv_ct.clone(), spec.clone()))
+                    } else {
+                        None
+                    };
+
+                if spec.prec() > 0 {
+                    self.state_stack.push(TokenOrRedirect::Number(
+                        Number::from(r.denom()),
+                        left_directed_op,
+                    ));
+
+                    self.state_stack.push(TokenOrRedirect::Op(
+                        rdiv_ct,
+                        spec.clone(),
+                    ));
+
+                    self.state_stack.push(TokenOrRedirect::Number(
+                        Number::from(r.numer()),
+                        right_directed_op,
+                    ));
+                } else {
+                    self.state_stack.push(TokenOrRedirect::Close);
+
+                    self.state_stack.push(TokenOrRedirect::Number(
+                        Number::from(r.denom()),
+                        None,
+                    ));
+
+                    self.state_stack.push(TokenOrRedirect::Comma);
+
+                    self.state_stack.push(TokenOrRedirect::Number(
+                        Number::from(r.numer()),
+                        None,
+                    ));
+
+                    self.state_stack.push(TokenOrRedirect::Open);
+                    self.state_stack.push(TokenOrRedirect::Atom(rdiv_ct));
+                }
+
+                return;
+            }
+            _ => {
+                unreachable!()
+            }
+        }
+    }
+
     fn print_char(&mut self, is_quoted: bool, c: char)
     {
         if non_quoted_token(once(c)) {
@@ -1024,56 +1112,67 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
         }
     }
 
-    fn print_string(
+    fn print_proper_string(&mut self, buf: String, max_depth: usize) {
+        self.push_char('"');
+
+        let buf =
+            if max_depth == 0 {
+                String::from_iter(buf.chars().map(|c| {
+                    char_to_string(self.quoted, c)
+                }))
+            } else {
+                let mut char_count = 0;
+                let mut buf =
+                    String::from_iter(buf.chars().take(max_depth).map(|c| {
+                        char_count += 1;
+                        char_to_string(self.quoted, c)
+                    }));
+
+                if char_count == max_depth {
+                    buf += " ...";
+                }
+
+                buf
+            };
+
+        self.append_str(&buf);
+        self.push_char('"');
+    }
+
+    fn print_list_like(
         &mut self,
         iter: &mut HCPreOrderIterator,
+        addr: Addr,
         mut max_depth: usize,
-        h: usize,
-        n: usize,
     ) {
-        iter.stack().pop();
-        iter.stack().pop();
-
         if self.check_max_depth(&mut max_depth) {
+            iter.stack().pop();
+            iter.stack().pop();
+
             self.state_stack.push(TokenOrRedirect::Atom(clause_name!("...")));
             return;
         }
 
         let mut heap_pstr_iter =
-            self.machine_st.heap_pstr_iter(Addr::PStrLocation(h, n));
+            self.machine_st.heap_pstr_iter(addr);
 
         let buf = heap_pstr_iter.to_string();
+
+        if buf.is_empty() {
+            self.push_list(iter, max_depth);
+            return;
+        }
+
+        iter.stack().pop();
+        iter.stack().pop();
+
         let end_addr = heap_pstr_iter.focus();
 
         let at_cdr = self.at_cdr(",");
 
         if !at_cdr && Addr::EmptyList == end_addr {
-            if !self.machine_st.flags.double_quotes.is_codes() {
-                self.push_char('"');
-
-                let buf =
-                    if max_depth == 0 {
-                        String::from_iter(buf.chars().map(|c| {
-                            char_to_string(self.quoted, c)
-                        }))
-                    } else {
-                        let mut char_count = 0;
-                        let mut buf =
-                            String::from_iter(buf.chars().take(max_depth).map(|c| {
-                                char_count += 1;
-                                char_to_string(self.quoted, c)
-                            }));
-
-                        if char_count == max_depth {
-                            buf += " ...";
-                        }
-
-                        buf
-                    };
-
-                self.append_str(&buf);
-                self.push_char('"');
-
+            if !self.ignore_ops {
+                self.print_proper_string(buf, max_depth);
                 return;
             }
         }
@@ -1089,26 +1188,14 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
 
         let mut byte_len = 0;
 
-        let char_printer = |printer: &mut Self, c| {
-            if printer.machine_st.flags.double_quotes.is_codes() {
-                let s = (c as u32).to_string();
-
-                push_space_if_amb!(printer, &s, {
-                    printer.append_str(&s);
-                });
-            } else {
-                printer.print_char(printer.quoted, c);
-            }
-        };
-
         if self.ignore_ops {
             let mut char_count = 0;
 
             for c in buf_iter {
-                self.push_char('.');
+                self.append_str("'.'");
                 self.push_char('(');
 
-                char_printer(self, c);
+                self.print_char(self.quoted, c);
                 self.push_char(',');
 
                 char_count += 1;
@@ -1134,7 +1221,7 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
             };
 
             for c in buf_iter {
-                char_printer(self, c);
+                self.print_char(self.quoted, c);
                 self.push_char(',');
 
                 byte_len += c.len_utf8();
@@ -1211,6 +1298,7 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
                     !iter.immediate_leaf_has_property(|addr, heap| {
                         match heap.index_addr(&addr).as_ref() {
                             &HeapCellValue::Integer(ref n) => &**n >= &0,
+                            &HeapCellValue::Addr(Addr::Fixnum(n)) => n >= 0,
                             &HeapCellValue::Addr(Addr::Float(f)) => f >= OrderedFloat(0f64),
                             &HeapCellValue::Rational(ref r) => &**r >= &0,
                             _ => false
@@ -1245,6 +1333,66 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
         }
     }
 
+    fn print_tcp_listener(
+        &mut self,
+        iter: &mut HCPreOrderIterator,
+        tcp_listener: &TcpListener,
+        max_depth: usize,
+    ) {
+        let (ip, port) =
+            if let Some(addr) = tcp_listener.local_addr().ok() {
+                (addr.ip(), Number::from(addr.port() as isize))
+            } else {
+                let disconnected_atom = clause_name!("$disconnected_tcp_listener");
+                self.state_stack.push(TokenOrRedirect::Atom(disconnected_atom));
+
+                return;
+            };
+
+        if self.format_struct(iter, max_depth, 1, clause_name!("$tcp_listener")) {
+            let atom = self.state_stack.pop().unwrap();
+
+            self.state_stack.pop();
+            self.state_stack.pop();
+
+            self.state_stack.push(TokenOrRedirect::Number(port, None));
+            self.state_stack.push(TokenOrRedirect::Comma);
+            self.state_stack.push(TokenOrRedirect::IpAddr(ip));
+
+            self.state_stack.push(TokenOrRedirect::Open);
+            self.state_stack.push(atom);
+        }
+    }
+
+    fn print_stream(
+        &mut self,
+        iter: &mut HCPreOrderIterator,
+        stream: &Stream,
+        max_depth: usize,
+    ) {
+        if let Some(alias) = &stream.options.alias {
+            self.print_atom(alias);
+        } else {
+            if self.format_struct(iter, max_depth, 1, clause_name!("$stream")) {
+                let atom =
+                    if stream.is_stdout() || stream.is_stdin() {
+                        TokenOrRedirect::Atom(clause_name!("user"))
+                    } else {
+                        TokenOrRedirect::RawPtr(stream.as_ptr())
+                    };
+
+                let stream_root = self.state_stack.pop().unwrap();
+
+                self.state_stack.pop();
+                self.state_stack.pop();
+
+                self.state_stack.push(atom);
+                self.state_stack.push(TokenOrRedirect::Open);
+                self.state_stack.push(stream_root);
+            }
+        }
+    }
+
     fn handle_heap_term(
         &mut self,
         iter: &mut HCPreOrderIterator,
@@ -1261,7 +1409,7 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
 
         match self.machine_st.heap.index_addr(&addr).as_ref() {
             &HeapCellValue::NamedStr(arity, ref name, ref spec) => {
-                let spec = fetch_op_spec(name.clone(), arity, spec.clone(), self.op_dir);
+                let spec = fetch_op_spec_from_existing(name.clone(), arity, spec.clone(), self.op_dir);
 
                 if let Some(spec) = spec {
                     self.handle_op_as_struct(
@@ -1308,9 +1456,6 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
                     });
                 }
             }
-            &HeapCellValue::Addr(Addr::CharCode(c)) => {
-                self.append_str(&format!("{}", c as u32));
-            }
             &HeapCellValue::Addr(Addr::Char(c)) => {
                 self.print_char(self.quoted, c);
             }
@@ -1332,13 +1477,13 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
                 self.append_str(&format!("{}", u));
             }
             &HeapCellValue::Addr(Addr::PStrLocation(h, n)) => {
-                self.print_string(iter, max_depth, h, n);
+                self.print_list_like(iter, Addr::PStrLocation(h, n), max_depth);
             }
-            &HeapCellValue::Addr(Addr::Lis(_)) => {
+            &HeapCellValue::Addr(Addr::Lis(l)) => {
                 if self.ignore_ops {
                     self.format_struct(iter, max_depth, 2, clause_name!("."));
                 } else {
-                    self.push_list(iter, max_depth);
+                    self.print_list_like(iter, Addr::Lis(l), max_depth);
                 }
             }
             &HeapCellValue::Addr(addr) => {
@@ -1355,15 +1500,10 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
                 self.print_number(Number::Rational(n.clone()), &op);
             }
             &HeapCellValue::Stream(ref stream) => {
-                if let Some(alias) = &stream.options.alias {
-                    self.print_atom(alias);
-                } else {
-                    if stream.is_stdout() || stream.is_stdin() {
-                        self.print_atom(&clause_name!("user"));
-                    } else {
-                        self.format_struct(iter, max_depth, 1, clause_name!("$stream"));
-                    }
-                }
+                self.print_stream(iter, stream, max_depth);
+            }
+            &HeapCellValue::TcpListener(ref tcp_listener) => {
+                self.print_tcp_listener(iter, tcp_listener, max_depth);
             }
             _ => {
                 unreachable!()
@@ -1401,6 +1541,8 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
                         self.handle_heap_term(&mut iter, None, true, max_depth)
                     }
                     TokenOrRedirect::Close => self.push_char(')'),
+                    TokenOrRedirect::IpAddr(ip) => self.print_ip_addr(ip),
+                    TokenOrRedirect::RawPtr(ptr) => self.print_raw_ptr(ptr),
                     TokenOrRedirect::Open => self.push_char('('),
                     TokenOrRedirect::OpenList(delimit) => {
                         if !self.at_cdr(",") {
@@ -1416,6 +1558,7 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
                         }
                     }
                     TokenOrRedirect::HeadTailSeparator => self.append_str("|"),
+                    TokenOrRedirect::Number(n, op) => self.print_number(n, &op),
                     TokenOrRedirect::Comma => self.append_str(","),
                     TokenOrRedirect::Space => self.push_char(' '),
                     TokenOrRedirect::LeftCurly => self.push_char('{'),

src/indexing.rs

@@ -1,22 +1,26 @@
-use prolog_parser::ast::*;
+use crate::prolog_parser::ast::*;
+use crate::prolog_parser::tabled_rc::*;
 
-use crate::prolog::instructions::*;
-use crate::prolog::rug::Integer;
+use crate::instructions::*;
+use crate::rug::Integer;
 
-use indexmap::IndexMap;
+use crate::indexmap::IndexMap;
 
 use std::collections::VecDeque;
+use std::convert::TryFrom;
 use std::hash::Hash;
 use std::rc::Rc;
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 enum IntIndex {
     External(usize),
     Fail,
     Internal(usize),
 }
 
+#[derive(Debug)]
 pub struct CodeOffsets {
+    atom_tbl: TabledData<Atom>,
     pub constants: IndexMap<Constant, ThirdLevelIndex>,
     pub lists: ThirdLevelIndex,
     pub structures: IndexMap<(ClauseName, usize), ThirdLevelIndex>,
@@ -25,6 +29,7 @@ pub struct CodeOffsets {
 impl CodeOffsets {
     pub fn new() -> Self {
         CodeOffsets {
+            atom_tbl: TabledData::new(Rc::new("_index".to_string())),
             constants: IndexMap::new(),
             lists: Vec::new(),
             structures: IndexMap::new(),
@@ -50,15 +55,39 @@ impl CodeOffsets {
         }
     }
 
-    fn intercept_constant(&mut self, constant: &Constant, index: usize) {
+    fn intercept_overlapping_constant(&mut self, constant: &Constant, index: usize) {
         match constant {
-            &Constant::Atom(ref name, _) if name.is_char() => {
+            &Constant::Atom(ref name, ref op) if name.is_char() => {
                 let c = name.as_str().chars().next().unwrap();
                 let code = self.constants
                     .entry(Constant::Char(c))
                     .or_insert(vec![]);
 
                 code.push(Self::add_index(code.is_empty(), index));
+
+                if op.is_some() {
+                    let code = self.constants
+                        .entry(Constant::Atom(name.clone(), None))
+                        .or_insert(vec![]);
+
+                    code.push(Self::add_index(false, index));
+                }
+            }
+            &Constant::Atom(ref name, Some(_)) => {
+                let code = self.constants
+                    .entry(Constant::Atom(name.clone(), None))
+                    .or_insert(vec![]);
+
+                code.push(Self::add_index(code.is_empty(), index));
+            }
+            &Constant::Char(c) => {
+                let atom = clause_name!(c.to_string(), self.atom_tbl.clone());
+
+                let code = self.constants
+                    .entry(Constant::Atom(atom, None))
+                    .or_insert(vec![]);
+
+                code.push(Self::add_index(code.is_empty(), index));
             }
             &Constant::Fixnum(n) => {
                 let code = self.constants
@@ -66,6 +95,16 @@ impl CodeOffsets {
                     .or_insert(vec![]);
 
                 code.push(Self::add_index(code.is_empty(), index));
+
+                if n >= 0 {
+                    if let Ok(n) = usize::try_from(n) {
+                        let code = self.constants
+                            .entry(Constant::Usize(n))
+                            .or_insert(vec![]);
+
+                        code.push(Self::add_index(code.is_empty(), index));
+                    }
+                }
             }
             &Constant::Integer(ref n) => {
                 if let Some(n) = n.to_isize() {
@@ -75,10 +114,29 @@ impl CodeOffsets {
 
                     code.push(Self::add_index(code.is_empty(), index));
                 }
+
+                if let Some(n) = n.to_usize() {
+                    let code = self.constants
+                        .entry(Constant::Usize(n))
+                        .or_insert(vec![]);
+
+                    code.push(Self::add_index(code.is_empty(), index));
+                }
             }
-            &Constant::String(_) => {
-                let is_initial_index = self.lists.is_empty();
-                self.lists.push(Self::add_index(is_initial_index, index));
+            &Constant::Usize(n) => {
+                let code = self.constants
+                    .entry(Constant::Integer(Rc::new(Integer::from(n))))
+                    .or_insert(vec![]);
+
+                code.push(Self::add_index(code.is_empty(), index));
+
+                if let Ok(n) = isize::try_from(n) {
+                    let code = self.constants
+                        .entry(Constant::Fixnum(n))
+                        .or_insert(vec![]);
+
+                    code.push(Self::add_index(code.is_empty(), index));
+                }
             }
             _ => {
             }
@@ -96,12 +154,12 @@ impl CodeOffsets {
                 let is_initial_index = code.is_empty();
                 code.push(Self::add_index(is_initial_index, index));
             }
-            &Term::Cons(..) => {
+            &Term::Cons(..) | &Term::Constant(_, Constant::String(_)) => {
                 let is_initial_index = self.lists.is_empty();
                 self.lists.push(Self::add_index(is_initial_index, index));
             }
             &Term::Constant(_, ref constant) => {
-                self.intercept_constant(constant, index);
+                self.intercept_overlapping_constant(constant, index);
 
                 let code = self.constants
                     .entry(constant.clone())
@@ -110,7 +168,8 @@ impl CodeOffsets {
                 let is_initial_index = code.is_empty();
                 code.push(Self::add_index(is_initial_index, index));
             }
-            _ => {}
+            _ => {
+            }
         };
     }
 

src/instructions.rs

@@ -1,13 +1,13 @@
-use prolog_parser::ast::*;
+use crate::prolog_parser::ast::*;
 
-use crate::prolog::clause_types::*;
-use crate::prolog::forms::*;
-use crate::prolog::machine::heap::*;
-use crate::prolog::machine::machine_errors::MachineStub;
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::rug::Integer;
+use crate::clause_types::*;
+use crate::forms::*;
+use crate::machine::heap::*;
+use crate::machine::machine_errors::MachineStub;
+use crate::machine::machine_indices::*;
+use crate::rug::Integer;
 
-use indexmap::IndexMap;
+use crate::indexmap::IndexMap;
 
 use std::collections::VecDeque;
 use std::rc::Rc;
@@ -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/iterators.rs

@@ -1,16 +1,17 @@
-use prolog_parser::ast::*;
+use crate::prolog_parser::ast::*;
 
-use crate::prolog::clause_types::*;
-use crate::prolog::forms::*;
-use crate::prolog::machine::machine_indices::*;
+use crate::clause_types::*;
+use crate::forms::*;
+use crate::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),
@@ -90,6 +92,10 @@ fn is_partial_string<'a>(
         Term::Constant(_, Constant::EmptyList) => {
             return Some((string, None));
         }
+        Term::Constant(_, Constant::String(tail)) => {
+            string += &tail;
+            return Some((string, None));
+        }
         _ => {
             return None;
         }
@@ -124,6 +130,7 @@ impl<'a> TermIterState<'a> {
     }
 }
 
+#[derive(Debug)]
 pub struct QueryIterator<'a> {
     state_stack: Vec<TermIterState<'a>>,
 }
@@ -294,6 +301,7 @@ impl<'a> Iterator for QueryIterator<'a> {
     }
 }
 
+#[derive(Debug)]
 pub struct FactIterator<'a> {
     state_queue: VecDeque<TermIterState<'a>>,
     iterable_root: bool,
@@ -402,6 +410,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 +448,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/lib/arithmetic.pl

@@ -0,0 +1,123 @@
+:- module(arithmetic, [expmod/4, lsb/2, msb/2, number_to_rational/2,
+                       number_to_rational/3,
+                       rational_numerator_denominator/3]).
+
+:- use_module(library(charsio), [write_term_to_chars/3]).
+:- use_module(library(error)).
+:- use_module(library(lists), [append/3, member/2]).
+
+expmod(Base, Expo, Mod, R) :-
+    (   member(N, [Base, Expo, Mod]), var(N) -> instantiation_error(expmod/4)
+    ;   member(N, [Base, Expo, Mod]), \+ integer(N) ->
+        type_error(integer, N, expmod/4)
+    ;   Expo < 0 -> domain_error(not_less_than_zero, Expo, expmod/4)
+    ;   expmod_(Base, Expo, Mod, 1, R)
+    ).
+
+expmod_(_, _, 1, _, 0) :- !.
+expmod_(_, 0, _, R, R) :- !.
+expmod_(Base0, Expo0, Mod, C0, R) :-
+    Expo0 /\ 1 =:= 1,
+    C is (C0 * Base0) mod Mod,
+    !,
+    Expo is Expo0 >> 1,
+    Base is (Base0 * Base0) mod Mod,
+    expmod_(Base, Expo, Mod, C, R).
+expmod_(Base0, Expo0, Mod, C, R) :-
+    Expo is Expo0 >> 1,
+    Base is (Base0 * Base0) mod Mod,
+    expmod_(Base, Expo, Mod, C, R).
+
+lsb(X, N) :-
+    builtins:must_be_number(X, lsb/2),
+    (   \+ integer(X) -> type_error(integer, X, lsb/2)
+    ;   X < 1 -> domain_error(not_less_than_one, X, lsb/2)
+    ;   builtins:can_be_number(N, lsb/2),
+        X1 is X /\ (-X),
+        msb_(X1, -1, N)
+    ).
+
+msb(X, N) :-
+    builtins:must_be_number(X, msb/2),
+    (   \+ integer(X) -> type_error(integer, X, msb/2)
+    ;   X < 1 -> domain_error(not_less_than_one, X, msb/2)
+    ;   builtins:can_be_number(N, msb/2),
+        X1 is X >> 1,
+        msb_(X1, 0, N)
+    ).
+
+msb_(0, N, N) :- !.
+msb_(X, M, N) :-
+    X1 is X >> 1,
+    M1 is M + 1,
+    msb_(X1, M1, N).
+
+number_to_rational(Real, Fraction) :-
+    (   var(Real) -> instantiation_error(number_to_rational/2)
+    ;   integer(Real) -> Fraction is Real rdiv 1
+    ;   (rational(Real) ; float(Real)) ->
+            number_to_rational(1.0e-6, Real, Fraction)
+    ;   type_error(number, Real, number_to_rational/2)
+    ).
+
+% If 0 <= Eps0 <= 1e-16 then the search is for "infinite" precision.
+number_to_rational(Eps0, Real0, Fraction) :-
+    (   var(Eps0) -> instantiation_error(number_to_rational/3)
+    ;   \+ number(Eps0) -> type_error(number, Eps0, number_to_rational/3)
+    ;   Eps0 < 0 -> domain_error(not_less_than_zero, Eps0, number_to_rational/3)
+    ;   Eps_ is Eps0 rdiv 1,
+        rational_numerator_denominator(Eps_, EpsN, EpsD),
+        Eps = EpsN/EpsD
+    ),
+    (   var(Real0) -> instantiation_error(number_to_rational/3)
+    ;   \+ number(Real0) -> type_error(number, Eps0, number_to_rational/3)
+    ;   Real_ is Real0 rdiv 1,
+        rational_numerator_denominator(Real_, RealN, RealD),
+        Real = RealN/RealD
+    ),
+    E0/E1 = Eps,
+    P0/Q0 = Real,
+    (   P0 < 0 -> I1 is -1 + P0 // Q0
+    ;   I1 is P0 // Q0
+    ),
+    P1 is P0 mod Q0,
+    Q1 = Q0,
+    (   P1 =:= 0 -> Fraction is I1 + 0 rdiv 1
+    ;   Qn1n is max(P1 * E1 - Q1 * E0, 0),
+        Qn1d is Q1 * E1,
+        Qn1 = Qn1n/Qn1d,
+        Qp1n is P1 * E1 + Q1 * E0,
+        Qp1d = Qn1d,
+        Qp1 = Qp1n/Qp1d,
+        stern_brocot_(Qn1, Qp1, 0/1, 1/0, P2/Q2),
+        Fraction is I1 + P2 rdiv Q2
+    ),
+    !.
+
+number(X) :-
+    (   integer(X)
+    ;   float(X)
+    ;   rational(X)
+    ).
+
+stern_brocot_(Qnn/Qnd, Qpn/Qpd, A/B, C/D, Fraction) :-
+    Fn1 is A + C,
+    Fd1 is B + D,
+    simplify_fraction(Fn1/Fd1, Fn/Fd),
+    S1 is sign(Fn * Qnd - Fd * Qnn),
+    S2 is sign(Fn * Qpd - Fd * Qpn),
+    (   S1 < 0 -> stern_brocot_(Qnn/Qnd, Qpn/Qpd, Fn/Fd, C/D, Fraction)
+    ;   S2 > 0 -> stern_brocot_(Qnn/Qnd, Qpn/Qpd, A/B, Fn/Fd, Fraction)
+    ;   Fraction = Fn/Fd
+    ).
+
+simplify_fraction(A0/B0, A/B) :-
+    G is gcd(A0, B0),
+    A is A0 // G,
+    B is B0 // G.
+
+rational_numerator_denominator(R, N, D) :-
+    write_term_to_chars(R, [], Cs),
+    append(Ns, [' ', r, d, i, v, ' '|Ds], Cs),
+    number_chars(N, Ns),
+    number_chars(D, Ds).

src/lib/atts.pl

@@ -1,9 +1,10 @@
 :- module(atts, [op(1199, fx, attribute), call_residue_vars/2,
-		 '$absent_attr'/2, '$copy_attr_list'/2, '$get_attr'/2,
-		 '$put_attr'/2, '$absent_from_list'/2,
-		 '$get_from_list'/3, '$add_to_list'/3, '$del_attr'/3,
-		 '$del_attr_step'/3, '$del_attr_buried'/4,
-		 '$default_attr_list'/4]).
+                 term_attributed_variables/2,
+		         '$absent_attr'/2, '$copy_attr_list'/2, '$get_attr'/2,
+		         '$put_attr'/2, '$absent_from_list'/2,
+		         '$get_from_list'/3, '$add_to_list'/3, '$del_attr'/3,
+		         '$del_attr_step'/3, '$del_attr_buried'/4,
+		         '$default_attr_list'/4]).
 
 :- use_module(library(dcgs)).
 :- use_module(library(terms)).
@@ -56,7 +57,8 @@
 '$del_attr'(Ls0, V, Attr) :-
     Ls0 = [Att | Ls1],
     nonvar(Att),
-    (  Att \= Attr -> '$del_attr_buried'(Ls0, Ls1, V, Attr)
+    (  Att \= Attr ->
+       '$del_attr_buried'(Ls0, Ls1, V, Attr)
     ;  '$enqueue_attr_var'(V),
        '$del_attr_head'(V),
        '$del_attr'(Ls1, V, Attr)
@@ -158,3 +160,6 @@ call_residue_vars(Goal, Vars) :-
     '$get_attr_var_queue_delim'(B),
     call(Goal),
     '$get_attr_var_queue_beyond'(B, Vars).
+
+term_attributed_variables(Term, Vars) :-
+    '$term_attributed_variables'(Term, Vars).

src/lib/between.pl

@@ -9,7 +9,11 @@ between(Lower, Upper, X) :-
     must_be(integer, Lower),
     must_be(integer, Upper),
     can_be(integer, X),
-    between_(Lower, Upper, X). 
+    (   nonvar(X) ->
+        Lower =< X,
+        X =< Upper
+    ;   between_(Lower, Upper, X)
+    ).
 
 between_(Lower, Upper, Lower) :-
     Lower =< Upper.

src/lib/builtins.pl

@@ -24,6 +24,8 @@ user:term_expansion((:- op(Pred, Spec, [Op | OtherOps])), OpResults) :-
 :- op(400, yfx, [div, //, rdiv, <<, >>, mod, rem]).
 :- op(200, fy, [+, -, \]).
 
+:- op(1200, xfx, -->).
+
 % arithmetic comparison operators.
 :- op(700, xfx, [>, <, =\=, =:=, >=, =<]).
 
@@ -41,25 +43,35 @@ user:term_expansion((:- op(Pred, Spec, [Op | OtherOps])), OpResults) :-
 :- module(builtins, [(=)/2, (\=)/2, (\+)/1, (',')/2, (->)/2, (;)/2,
                      (=..)/2, (:)/2, (:)/3, (:)/4, (:)/5, (:)/6,
                      (:)/7, (:)/8, (:)/9, (:)/10, (:)/11, (:)/12,
-                     abolish/1, asserta/1, assertz/1, atom_chars/2,
-                     atom_codes/2, atom_concat/3, atom_length/2,
-                     bagof/3, catch/3, char_code/2, clause/2,
-                     current_input/1, current_output/1, current_op/3,
+                     abolish/1, asserta/1, assertz/1,
+                     at_end_of_stream/0, at_end_of_stream/1,
+                     atom_chars/2, atom_codes/2, atom_concat/3,
+                     atom_length/2, bagof/3, catch/3, char_code/2,
+                     clause/2, close/1, close/2, current_input/1,
+                     current_output/1, current_op/3,
                      current_predicate/1, current_prolog_flag/2,
                      expand_goal/2, expand_term/2, fail/0, false/0,
-                     findall/3, findall/4, get_char/1, halt/0,
-                     max_arity/1, number_chars/2, number_codes/2,
-                     once/1, op/3, read_term/2, repeat/0, retract/1,
-                     set_prolog_flag/2, set_input/1, set_output/1,
-                     setof/3, sub_atom/5, subsumes_term/2,
-                     term_variables/2, throw/1, true/0,
-                     unify_with_occurs_check/2, write/1,
-                     write_canonical/1, write_term/2, writeq/1]).
+                     findall/3, findall/4, flush_output/0,
+                     flush_output/1, get_byte/1, get_byte/2,
+                     get_char/1, get_char/2, get_code/1, get_code/2,
+                     halt/0, halt/1, max_arity/1, number_chars/2,
+                     number_codes/2, once/1, op/3, open/3, open/4,
+                     peek_byte/1, peek_byte/2, peek_char/1,
+                     peek_char/2, peek_code/1, peek_code/2,
+                     put_byte/1, put_byte/2, put_code/1, put_code/2,
+                     put_char/1, put_char/2, read_term/2, read_term/3,
+                     repeat/0, retract/1, set_prolog_flag/2,
+                     set_input/1, set_stream_position/2, set_output/1,
+                     setof/3, stream_property/2, sub_atom/5,
+                     subsumes_term/2, term_variables/2, throw/1,
+                     true/0, unify_with_occurs_check/2, write/1,
+                     write_canonical/1, write_term/2, write_term/3,
+                     writeq/1]).
 
 
 % the maximum arity flag. needs to be replaced with
 % current_prolog_flag(max_arity, MAX_ARITY).
-max_arity(255).
+max_arity(1023).
 
 % unify.
 X = X.
@@ -213,18 +225,41 @@ comma_errors(G1, G2, B) :- '$call_with_default_policy'(','(G1, G2, B)).
 
 ;(G1, G2) :- '$get_b_value'(B), ;(G1, G2, B).
 
+:- non_counted_backtracking semicolon_compound_selector/3.
+semicolon_compound_selector(->(G2, G3), G4, B) :-
+    (  call(G2) ->
+       call(G3)
+    ;  '$set_cp'(B),
+       call(G4)
+    ).
+semicolon_compound_selector(','(G2, G3), G4, B) :-
+    (  ','(G2, G3, B)
+    ;  '$set_cp'(B),
+       call(G4)
+    ).
+semicolon_compound_selector(';'(G2, G3), G4, B) :-
+    (  ';'(G2, G3, B)
+    ;  '$set_cp'(B),
+       call(G4)
+    ).
+
 :- non_counted_backtracking (;)/3.
-;(G1, G4, B) :- compound(G1),
-		'$call_with_default_policy'(G1 = ->(G2, G3)),
-		!,
-		(  call(G2) -> call(G3)
-		;  '$set_cp'(B),
-		   call(G4)
-		).
-;(G1, G2, B) :- G1 == !, '$set_cp'(B), call(G2).
-;(G1, G2, B) :- G2 == !, call(G1), '$set_cp'(B).
-;(G, _, _) :- call(G).
-;(_, G, _) :- call(G).
+;(G1, G4, B) :-
+    ( (  G1 = (_ -> _)
+      ;  G1 = (_ , _)
+      ;  G1 = (_ ; _)
+      ) ->
+      !,
+      semicolon_compound_selector(G1, G4, B)
+    ).
+;(G1, G2, B) :-
+    G1 == !, !, '$set_cp'(B), call(G2).
+;(G1, G2, B) :-
+    G2 == !, !, call(G1), '$set_cp'(B).
+;(G, _, _) :-
+    call(G).
+;(_, G, _) :-
+    call(G).
 
 G1 -> G2 :- '$get_b_value'(B), '$call_with_default_policy'(->(G1, G2, B)).
 
@@ -289,36 +324,39 @@ get_args([Arg|Args], Func, I0, N) :-
     '$call_with_default_policy'(I1 is I0 + 1),
     '$call_with_default_policy'(get_args(Args, Func, I1, N)).
 
-% write, write_canonical, writeq, write_term.
-is_write_option(Functor) :-
-    Functor =.. [Name, Arg],
-    (  Arg == true -> true
-    ;  Arg == false -> true
-    ;  Name == variable_names -> must_be_var_names_list(Arg)
-    ;  Name == max_depth -> integer(Arg), Arg >= 0
-    ;  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
-    ;  Name == max_depth -> true
-    ;  throw(error(domain_error(write_option, Functor), write_term/2))
-    ). % 8.14.2.3 e)
+parse_write_options(Options, OptionValues, Stub) :-
+    DefaultOptions = [ignore_ops-false, max_depth-0, numbervars-false,
+                      quoted-false, variable_names-[]],
+    parse_options_list(Options, parse_write_options_, DefaultOptions, OptionValues, Stub).
 
-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, Z) )
-    ;  throw(error(domain_error(write_option, X), write_term/2))
+parse_write_options_(ignore_ops(IgnoreOps), ignore_ops-IgnoreOps) :-
+    (  nonvar(IgnoreOps), lists:member(IgnoreOps, [true, false])
+    ;
+       throw(error(domain_error(write_option, ignore_ops(IgnoreOps)), _))
+    ).
+parse_write_options_(quoted(Quoted), quoted-Quoted) :-
+    (  nonvar(Quoted), lists:member(Quoted, [true, false])
+    ;
+       throw(error(domain_error(write_option, quoted(Quoted)), _))
+    ).
+parse_write_options_(numbervars(NumberVars), numbervars-NumberVars) :-
+    (  nonvar(NumberVars), lists:member(NumberVars, [true, false])
+    ;
+       throw(error(domain_error(write_option, numbervars(NumberVars)), _))
+    ).
+parse_write_options_(variable_names(VNNames), variable_names-VNNames) :-
+    must_be_var_names_list(VNNames).
+parse_write_options_(max_depth(MaxDepth), max_depth-MaxDepth) :-
+    (  integer(MaxDepth), MaxDepth >= 0
+    ;
+       throw(error(domain_error(write_option, max_depth(MaxDepth)), _))
     ).
-inst_member_or([], Y, Y).
 
 must_be_var_names_list(VarNames) :-
     '$skip_max_list'(_, -1, VarNames, Tail),
     (  Tail == [] -> must_be_var_names_list_(VarNames, VarNames)
     ;  var(Tail)  -> throw(error(instantiation_error, write_term/2))
-    ;  throw(error(domain_error(write_options, variable_names(VarNames)), write_term/2))
+    ;  throw(error(domain_error(write_option, variable_names(VarNames)), write_term/2))
     ).
 
 must_be_var_names_list_([], List).
@@ -327,45 +365,90 @@ must_be_var_names_list_([VarName | VarNames], List) :-
        (  VarName = (Atom = _) ->
 	      (  atom(Atom) -> must_be_var_names_list_(VarNames, List)
 	      ;  var(Atom)  -> throw(error(instantiation_error, write_term/2))
-	      ;  throw(error(domain_error(write_options, variable_names(List)), write_term/2))
+	      ;  throw(error(domain_error(write_option, variable_names(List)), write_term/2))
 	      )
-       ;  throw(error(domain_error(write_options, variable_names(List)), write_term/2))
+       ;  throw(error(domain_error(write_option, variable_names(List)), write_term/2))
        )
-    ;  throw(error(instantiation_error, write_term/2)) % throw(error(domain_error(write_options, variable_names(List)), 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) :-
-    '$skip_max_list'(_, -1, Options, Options0),
-    (  var(Options0)  -> throw(error(instantiation_error, write_term/2))
-    ;  Options0 == [] -> true
-    ;  throw(error(type_error(list, Options), write_term/2))
-    ), % 8.14.2.3 c)
-    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)),
-    inst_member_or(Options, variable_names(VarNames), variable_names([])),
-    inst_member_or(Options, max_depth(MaxDepth), max_depth(0)),
-    '$write_term'(Term, IgnoreOps, NumberVars, Quoted, VarNames, MaxDepth).
+    current_output(Stream),
+    write_term(Stream, Term, Options).
 
-write(Term) :- write_term(Term, [numbervars(true)]).
+write_term(Stream, Term, Options) :-
+    parse_write_options(Options, [IgnoreOps, MaxDepth, NumberVars, Quoted, VNNames], write_term/3),
+    '$write_term'(Stream, Term, IgnoreOps, NumberVars, Quoted, VNNames, MaxDepth).
 
-write_canonical(Term) :- write_term(Term, [ignore_ops(true), quoted(true)]).
 
-writeq(Term) :- write_term(Term, [quoted(true), numbervars(true)]).
+write(Term) :-
+    current_output(Stream),
+    '$write_term'(Stream, Term, false, true, false, [], 0).
 
-%% TODO: complete the predicate! Most read options are missing.
-read_term(Term, Options) :-
-    '$skip_max_list'(_, -1, Options, Options0),
-    (  Options0 == [] -> true
-    ;  var(Options0)  -> throw(error(instantiation_error, read_term/2)) % 8.14.1.3 b)
-    ;  throw(error(type_error(list, Options), read_term/2)) % 8.14.1.3 d)
-    ),
-    (  Options = [variable_names(VarList)] -> '$read_term'(Term, VarList)
-    ;  Options = [] -> read(Term)
-    ;  false
+write_canonical(Term) :-
+    current_output(Stream),
+    '$write_term'(Stream, Term, true, false, true, [], 0).
+
+writeq(Term) :-
+    current_output(Stream),
+    '$write_term'(Stream, Term, false, true, true, [], 0).
+
+
+
+select_rightmost_options([Option-Value | OptionPairs], OptionValues) :-
+    (  pairs:same_key(Option, OptionPairs, OtherValues, _),
+       OtherValues == []  ->
+       OptionValues = [Value | OptionValues0],
+       select_rightmost_options(OptionPairs, OptionValues0)
+    ;
+       select_rightmost_options(OptionPairs, OptionValues)
     ).
+select_rightmost_options([], []).
+
+
+parse_options_list(Options, Selector, DefaultPairs, OptionValues, Stub) :-
+    '$skip_max_list'(_, -1, Options, Tail),
+    (  Tail == [] ->
+       true
+    ;  var(Tail) ->
+       throw(error(instantiation_error, Stub))       % 8.11.5.3c)
+    ;  Tail \== [] ->
+       throw(error(type_error(list, Options), Stub)) % 8.11.5.3e)
+    ),
+    (  lists:maplist(nonvar, Options),
+       catch(lists:maplist(Selector, Options, OptionPairs0),
+             error(E, _),
+             throw(error(E, Stub))) ->
+       lists:append(DefaultPairs, OptionPairs0, OptionPairs1),
+       keysort(OptionPairs1, OptionPairs),
+       select_rightmost_options(OptionPairs, OptionValues)
+    ;
+       throw(error(instantiation_error, Stub))       % 8.11.5.3c)
+    ).
+
+
+parse_read_term_options(Options, OptionValues, Stub) :-
+    DefaultOptions = [singletons-_, variables-_, variable_names-_],
+    parse_options_list(Options, parse_read_term_options_, DefaultOptions, OptionValues, Stub).
+
+
+parse_read_term_options_(singletons(Vars), singletons-Vars).
+parse_read_term_options_(variables(Vars), variables-Vars).
+parse_read_term_options_(variable_names(Vars), variable_names-Vars).
+parse_read_term_options_(E,_) :-
+    throw(error(domain_error(read_option, E), _)).
+
+
+
+read_term(Stream, Term, Options) :-
+    parse_read_term_options(Options, [Singletons, VariableNames, Variables], read_term/3),
+    '$read_term'(Stream, Term, Singletons, Variables, VariableNames).
+
+read_term(Term, Options) :-
+    current_input(Stream),
+    read_term(Stream, Term, Options).
+
 
 % expand_goal.
 
@@ -548,18 +631,19 @@ setof(Template, Goal, Solution) :-
 
 clause(H, B) :-
     (  var(H) -> throw(error(instantiation_error, clause/2))
-    ;  functor(H, Name, Arity) -> (  Name == '.' -> throw(error(type_error(callable, H), clause/2))
-				  ;  Name == (:), Arity =:= 2 ->
-				     arg(1, H, Module),
-				     arg(2, H, F),
-				     '$module_clause'(F, B, Module)
-				  %% '$no_such_predicate' fails if H is not callable.
-				  ;  '$no_such_predicate'(H) -> '$fail'
-				  ;  '$head_is_dynamic'(H) -> '$clause_body_is_valid'(B),
-							      '$get_clause'(H, B)
-				  ;  throw(error(permission_error(access, private_procedure, Name/Arity),
-						 clause/2))
-				  )
+    ;  functor(H, Name, Arity) ->
+       (  Name == '.' -> throw(error(type_error(callable, H), clause/2))
+	   ;  Name == (:), Arity =:= 2 ->
+		  arg(1, H, Module),
+		  arg(2, H, F),
+		  '$module_clause'(F, B, Module)
+	   %% '$no_such_predicate' fails if H is not callable.
+	   ;  '$no_such_predicate'(H) -> '$fail'
+	   ;  '$head_is_dynamic'(H) -> '$clause_body_is_valid'(B),
+							       '$get_clause'(H, B)
+	   ;  throw(error(permission_error(access, private_procedure, Name/Arity),
+					  clause/2))
+	   )
     ;  throw(error(type_error(callable, H), clause/2))
     ).
 
@@ -830,7 +914,14 @@ op(Priority, OpSpec, Op) :-
     ;  throw(error(type_error(list, Op), op/3)) % 8.14.3.3 f)
     ).
 
-halt :- '$halt'.
+
+halt :- halt(0).
+
+halt(N) :-
+        (   -2^31 =< N, N =< 2^31 - 1 ->
+            '$halt'(N)
+        ;   throw(error(domain_error(exit_code, N), halt/1))
+        ).
 
 atom_length(Atom, Length) :-
     (  var(Atom)  -> throw(error(instantiation_error, atom_length/2)) % 8.16.1.3 a)
@@ -850,10 +941,10 @@ atom_chars(Atom, List) :-
     ),
     (  var(Atom) ->
        (  var(Tail) -> throw(error(instantiation_error, atom_chars/2))
-       ;  ground(List), Tail == [] -> '$atom_chars'(Atom, List)
+       ;  ground(List) -> '$atom_chars'(Atom, List)
        ;  throw(error(instantiation_error, atom_chars/2))
        )
-    ;  atom(Atom) -> can_be_chars_or_vars(List, atom_chars/2), '$atom_chars'(Atom, List)
+    ;  atom(Atom) -> '$atom_chars'(Atom, List)
     ;  throw(error(type_error(atom, Atom), atom_chars/2))
     ).
 
@@ -867,7 +958,7 @@ atom_codes(Atom, List) :-
        ;  ground(List), Tail == [] -> '$atom_codes'(Atom, List)
        ;  throw(error(instantiation_error, atom_codes/2))
        )
-    ;  atom(Atom) -> can_be_codes_or_vars(List, atom_codes/2), '$atom_codes'(Atom, List)
+    ;  atom(Atom) -> '$atom_codes'(Atom, List)
     ;  throw(error(type_error(atom, Atom), atom_codes/2))
     ).
 
@@ -924,11 +1015,11 @@ char_code(Char, Code) :-
     ).
 
 get_char(C) :-
-    (  var(C) -> '$get_char'(C)
-    ;  C == end_of_file  -> '$get_char'(C)
-    ;  atom_length(C, 1) -> '$get_char'(C)
-    ;  throw(error(type_error(in_character, C), get_char/1))
-    ).
+    current_input(S),
+    '$get_char'(S, C).
+
+get_char(S, C) :-
+    '$get_char'(S, C).
 
 can_be_number(N, PI) :-
     (  var(N) -> true
@@ -945,45 +1036,6 @@ must_be_number(N, PI) :-
     ;  throw(error(instantiation_error, PI))
     ).
 
-can_be_chars_or_vars(Cs, _)  :- var(Cs), !.
-can_be_chars_or_vars(Cs, PI) :-
-    (  string(Cs) ->
-       current_prolog_flag(double_quotes, chars)
-    ;  chars_or_vars(Cs, PI)
-    ).
-
-chars_or_vars([], _).
-chars_or_vars([C|Cs], PI) :-
-    (  nonvar(C) ->
-       (  catch(atom_length(C, 1), _, false) ->
-	  (  nonvar(Cs) -> chars_or_vars(Cs, PI)
-	  ;  false
-	  )
-       ;  throw(error(type_error(character, C), PI))
-       )
-    ;  chars_or_vars(Cs, PI)
-    ).
-
-can_be_codes_or_vars(Cs, _)  :- var(Cs), !.
-can_be_codes_or_vars(Cs, PI) :-
-    (  string(Cs) ->
-       current_prolog_flag(double_quotes, codes)
-    ;  codes_or_vars(Cs, PI)
-    ).
-
-codes_or_vars([], _).
-codes_or_vars([C|Cs], PI) :-
-    (  nonvar(C) ->
-       (  catch(char_code(_, C), _, false) ->
-	  (  nonvar(Cs) -> codes_or_vars(Cs, PI)
-	  ;  false
-	  )
-       ;  integer(C) -> throw(error(representation_error(character_code), PI))
-       ;  throw(error(type_error(integer, C), PI))
-       )
-    ;  codes_or_vars(Cs, PI)
-    ).
-
 number_chars(N, Chs) :-
    (  ground(Chs)
    -> can_be_number(N, number_chars/2),
@@ -1039,3 +1091,210 @@ set_output(S) :-
        throw(error(instantiation_error, set_output/1))
     ;  '$set_output'(S)
     ).
+
+
+parse_stream_options(Options, OptionValues, Stub) :-
+    DefaultOptions = [alias-[], eof_action-eof_code, reposition-false, type-text],
+    parse_options_list(Options, parse_stream_options_, DefaultOptions, OptionValues, Stub).
+
+
+parse_stream_options_(type(Type), type-Type) :-
+    (  nonvar(Type), lists:member(Type, [text, binary]), !, true
+    ;
+       throw(error(domain_error(stream_option, type(Type)), _))
+    ).
+parse_stream_options_(reposition(Bool), reposition-Bool) :-
+    (  nonvar(Bool), lists:member(Bool, [true, false]), !, true
+    ;
+       throw(error(domain_error(stream_option, reposition(Bool)), _))
+    ).
+parse_stream_options_(alias(A), alias-A) :-
+    (  atom(A), A \== [], !, true
+    ;
+       throw(error(domain_error(stream_option, alias(A)), _))
+    ).
+parse_stream_options_(eof_action(Action), eof_action-Action) :-
+    (  nonvar(Action), lists:member(Action, [eof_code, error, reset]), !, true
+    ;
+       throw(error(domain_error(stream_option, eof_action(Action)), _))
+    ).
+parse_stream_options_(E, _) :-
+    throw(error(domain_error(stream_option, E), _)). % 8.11.5.3i)
+
+
+open(SourceSink, Mode, Stream) :-
+    open(SourceSink, Mode, Stream, []).
+
+open(SourceSink, Mode, Stream, StreamOptions) :-
+    (  var(SourceSink) ->
+       throw(error(instantiation_error, open/4)) % 8.11.5.3a)
+    ;  var(Mode) ->
+       throw(error(instantiation_error, open/4)) % 8.11.5.3b)
+    ;  \+ atom(Mode) ->
+       throw(error(type_error(atom, Mode), open/4)) % 8.11.5.3d)
+    ;  nonvar(Stream) ->
+       throw(error(type_error(variable, Stream), open/4)) % 8.11.5.3f)
+    ;
+       parse_stream_options(StreamOptions, [Alias, EOFAction, Reposition, Type], open/4),
+       '$open'(SourceSink, Mode, Stream, Alias, EOFAction, Reposition, Type)
+    ).
+
+
+parse_close_options(Options, OptionValues, Stub) :-
+    DefaultOptions = [force-false],
+    parse_options_list(Options, parse_close_options_, DefaultOptions, OptionValues, Stub).
+
+parse_close_options_(force(Force), force-Force) :-
+    (  nonvar(Force), lists:member(Force, [true, false]), !
+    ;
+       throw(error(domain_error(close_option, force(Force)), _))
+    ).
+parse_close_options_(E, _) :-
+    throw(error(domain_error(close_option, E), _)).
+
+
+close(Stream, CloseOptions) :-
+    parse_close_options(CloseOptions, [Force], close/2),
+    '$close'(Stream, CloseOptions).
+
+close(Stream) :-
+    '$close'(Stream, []).
+
+
+flush_output(S) :-
+    '$flush_output'(S).
+
+flush_output :-
+    current_output(S),
+    '$flush_output'(S).
+
+
+get_byte(S, B) :-
+    '$get_byte'(S, B).
+
+get_byte(B) :-
+    current_input(S),
+    '$get_byte'(S, B).
+
+
+put_char(C) :-
+    current_output(S),
+    '$put_char'(S, C).
+
+put_char(S, C) :-
+    '$put_char'(S, C).
+
+
+put_byte(C) :-
+    current_output(S),
+    '$put_byte'(S, C).
+
+put_byte(S, C) :-
+    '$put_byte'(S, C).
+
+
+put_code(C) :-
+    current_output(S),
+    '$put_code'(S, C).
+
+put_code(S, C) :-
+    '$put_code'(S, C).
+
+
+get_code(C) :-
+    current_input(S),
+    '$get_code'(S, C).
+
+get_code(S, C) :-
+    '$get_code'(S, C).
+
+
+peek_byte(S, B) :-
+    '$peek_byte'(S, B).
+
+peek_byte(B) :-
+    current_input(S),
+    '$peek_byte'(S, B).
+
+
+peek_code(C) :-
+    current_input(S),
+    '$peek_code'(S, C).
+
+peek_code(S, C) :-
+    '$peek_code'(S, C).
+
+
+peek_char(C) :-
+    current_input(S),
+    '$peek_char'(S, C).
+
+peek_char(S, C) :-
+    '$peek_char'(S, C).
+
+
+check_stream_property(file_name(F), file_name, F) :-
+    ( var(F) -> true ; atom(F) ).
+check_stream_property(mode(M), mode, M) :-
+    ( var(M) -> true ; lists:member(M, [read, write, append]) ).
+check_stream_property(D, direction, D) :-
+    ( var(D) -> true ; lists:member(D, [input, output, input_output]), ! ).
+check_stream_property(alias(A), alias, A) :-
+    ( var(A) -> true ; atom(A) ).
+check_stream_property(position(P), position, P) :-
+    ( var(P) -> true ; integer(P), P >= 0 ).
+check_stream_property(end_of_stream(E), end_of_stream, E) :-
+    ( var(E) -> true ; lists:member(E, [not, at, past]) ).
+check_stream_property(eof_action(A), eof_action, A) :-
+    ( var(A) -> true ; lists:member(A, [error, eof_code, reset]) ).
+check_stream_property(reposition(B), reposition, B) :-
+    ( var(B) -> true ; lists:member(B, [true, false]) ).
+check_stream_property(type(T), type, T) :-
+    ( var(T) -> true ; lists:member(T, [text, binary]) ).
+
+
+stream_iter_(S, S).
+stream_iter_(S, S1) :-
+    '$next_stream'(S, S0),
+    stream_iter_(S0, S1).
+
+stream_iter(S) :-
+    (  nonvar(S) ->
+       true
+    ;  '$first_stream'(S0),
+       stream_iter_(S0, S)
+    ).
+
+
+stream_property(S, P) :-
+    (  nonvar(P), \+ check_stream_property(P, _, _) ->
+       throw(error(domain_error(stream_property, P), stream_property/2))
+    ;  stream_iter(S),
+       check_stream_property(P, PropertyName, PropertyValue),
+       '$stream_property'(S, PropertyName, PropertyValue)
+    ).
+
+
+at_end_of_stream(S_or_a) :-
+    (  atom(S_or_a) ->
+       stream_property(S, alias(S_or_a))
+    ;  S = S_or_a
+    ),
+    stream_property(S, end_of_stream(E)),
+    ( E = at -> true ; E = past ).
+
+at_end_of_stream :-
+    current_input(S),
+    stream_property(S, end_of_stream(E)),
+    !,
+    ( E = at ; E = past ).
+
+
+set_stream_position(S_or_a, Position) :-
+    (  var(Position) ->
+       throw(error(instantiation_error, set_stream_position/2))
+    ;  integer(Position), Position >= 0 ->
+       true
+    ;  throw(error(domain_error(stream_position, Position)))
+    ),
+    '$set_stream_position'(S_or_a, Position).

src/lib/charsio.pl

@@ -0,0 +1,242 @@
+:- module(charsio, [char_type/2,
+                    chars_utf8bytes/2,
+                    get_single_char/1,
+                    read_line_to_chars/3,
+                    read_term_from_chars/2,
+                    write_term_to_chars/3,
+                    chars_base64/3]).
+
+:- use_module(library(dcgs)).
+:- use_module(library(iso_ext)).
+:- use_module(library(error)).
+:- use_module(library(lists)).
+
+fabricate_var_name(VarType, VarName, N) :-
+    char_code('A', AC),
+    LN is N mod 26 + AC,
+    char_code(LC, LN),
+    NN is N // 26,
+    (  NN =:= 0 ->
+       (  VarType == fabricated ->
+          atom_chars(VarName, ['_', LC])
+       ;  VarType == numbervars ->
+          atom_chars(VarName, [LC])
+       )
+    ;  number_chars(NN, NNChars),
+       (  VarType == fabricated ->
+          atom_chars(VarName, ['_', LC | NNChars])
+       ;  VarType == numbervars ->
+          atom_chars(VarName, [LC | NNChars])
+       )
+    ).
+
+var_list_contains_name([VarName = _ | VarList], VarName0) :-
+    (  VarName == VarName0 -> true
+    ;  var_list_contains_name(VarList, VarName0)
+    ).
+
+var_list_contains_variable([_ = Var | VarList], Var0) :-
+    (  Var == Var0 -> true
+    ;  var_list_contains_variable(VarList, Var0)
+    ).
+
+make_new_var_name(VarType, V, VarName, N, N1, VarList) :-
+    fabricate_var_name(VarType, VarName0, N),
+    (  var_list_contains_name(VarList, VarName0) ->
+       N0 is N + 1,
+       make_new_var_name(VarType, V, VarName, N0, N1, VarList)
+    ;  VarName = VarName0,
+       N1 is N + 1
+    ).
+
+extend_var_list(Vars, VarList, NewVarList, VarType) :-
+    extend_var_list_(Vars, 0, VarList, NewVarList0, VarType),
+    append(VarList, NewVarList0, NewVarList).
+
+extend_var_list_([], _, VarList, [], _).
+extend_var_list_([V|Vs], N, VarList, NewVarList, VarType) :-
+    (  var_list_contains_variable(VarList, V) ->
+       extend_var_list_(Vs, N, VarList, NewVarList, VarType)
+    ;  make_new_var_name(VarType, V, VarName, N, N1, VarList),
+       NewVarList = [VarName = V | NewVarList0],
+       extend_var_list_(Vs, N1, VarList, NewVarList0, VarType)
+    ).
+
+
+char_type(Char, Type) :-
+    (   var(Char) -> instantiation_error(char_type/2)
+    ;   atom_length(Char, 1) ->
+        (   ground(Type) ->
+            (   ctype(Type) ->
+                '$char_type'(Char, Type)
+            ;   domain_error(char_type, Type, char_type/2)
+            )
+        ;   ctype(Type),
+            '$char_type'(Char, Type)
+        )
+    ;   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)
+    ;  type_error(in_character, C, get_single_char/1)
+    ).
+
+
+read_term_from_chars(Chars, Term) :-
+    (  var(Chars) ->
+       instantiation_error(read_term_from_chars/2)
+    ;  nonvar(Term) ->
+       throw(error(uninstantiation_error(Term), read_term_from_chars/2))
+    ;  '$skip_max_list'(_, -1, Chars, Chars0),
+       Chars0 == [],
+       partial_string(Chars) ->
+       true
+    ;
+       type_error(complete_string, Chars, read_term_from_chars/2)
+    ),
+    '$read_term_from_chars'(Chars, Term).
+
+
+write_term_to_chars(_, Options, _) :-
+    var(Options), instantiation_error(write_term_to_chars/3).
+write_term_to_chars(Term, Options, Chars) :-
+    builtins:parse_write_options(Options,
+                                 [IgnoreOps, MaxDepth, NumberVars, Quoted, VNNames],
+                                 write_term_to_chars/3),
+    (  nonvar(Chars)  ->
+       throw(error(uninstantiation_error(Chars), write_term_to_chars/3))
+    ;
+       true
+    ),
+    term_variables(Term, Vars),
+    extend_var_list(Vars, VNNames, NewVarNames, numbervars),
+    '$write_term_to_chars'(Chars, Term, IgnoreOps, NumberVars, Quoted, NewVarNames, MaxDepth).
+
+% Encodes Ch character to list of Bytes.
+char_utf8bytes(Ch, Bytes) :-
+  char_code(Ch, Code),
+  phrase(code_to_utf8(Code), Bytes).
+
+code_to_utf8(Code) --> {Code @< 0x80},     [Code], !.
+code_to_utf8(Code) --> {Code @< 0x800},    encode(Code, 0xC0, 2), !.
+code_to_utf8(Code) --> {Code @< 0x10000},  encode(Code, 0xE0, 3), !.
+code_to_utf8(Code) --> {Code @< 0x110000}, encode(Code, 0xF0, 4), !.
+
+encode(_, _, 0) --> !.
+encode(Code, Prefix, Nb) -->
+  { Nb1 is Nb - 1, Byte is Prefix \/ ((Code >> (6 * Nb1)) /\ 0x3F) },
+  [Byte], encode(Code, 0x80, Nb1).
+
+% Maps characters and UTF-8 bytes.
+% If Cs is a variable, parses Bs as a list of UTF-8 bytes.
+% Otherwise, transform the list of characters Cs to UTF-8 bytes.
+chars_utf8bytes(Cs, Bs) :-
+  var(Cs), must_be(list, Bs) ->
+    once(phrase(decode_utf8(Cs), Bs))
+  ; (must_be(list, Cs),
+     maplist(must_be(atom), Cs),
+     maplist(char_utf8bytes, Cs, Bss),
+     append(Bss, Bs)).
+
+decode_utf8([]) --> [].
+decode_utf8(Chars) --> leading(Nb, Code), continuation(Code, Chars, Nb).
+
+leading(1, Byte) --> [Byte], {Byte /\ 0x80 =:= 0}.
+leading(2, Code) --> [Byte], {Byte /\ 0xE0 =:= 0xC0, Code is Byte - 0xC0}.
+leading(3, Code) --> [Byte], {Byte /\ 0xF0 =:= 0xE0, Code is Byte - 0xE0}.
+leading(4, Code) --> [Byte], {Byte /\ 0xF8 =:= 0xF0, Code is Byte - 0xF0}.
+leading(1, 0xFFFD) --> [_]. % invalid first byte
+
+continuation(Code, [H|T], 1) --> {char_code(H, Code)}, decode_utf8(T).
+continuation(Code, Chars, Nb) --> [Byte],
+  {Nb1 is Nb - 1, Byte /\ 0xC0 =:= 0x80, NextCode is (Code << 6) \/ (Byte - 0x80)},
+  continuation(NextCode, Chars, Nb1).
+
+% invalid continuation byte
+% each remaining continuation byte (if any) will raise 0xFFFD too
+continuation(_, ['\xFFFD\'|T], _) --> [_], decode_utf8(T).
+
+
+read_line_to_chars(Stream, Cs0, Cs) :-
+        '$get_n_chars'(Stream, 1, Char), % this also works for binary streams
+        (   Char == [] -> Cs0 = Cs
+        ;   Char = [C],
+            Cs0 = [C|Rest],
+            (   C == '\n' -> Rest = Cs
+            ;   read_line_to_chars(Stream, Rest, Cs)
+            )
+        ).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Relation between a list of characters Cs and its Base64 encoding Bs,
+   also a list of characters.
+
+   At least one of the arguments must be instantiated.
+
+   Options are:
+
+      - padding(Boolean)
+        Whether to use padding: true (the default) or false.
+      - charset(C)
+        Either 'standard' (RFC 4648 §4, the default) or 'url' (RFC 4648 §5).
+
+   Example:
+
+      ?- chars_base64("hello", Bs, []).
+         Bs = "aGVsbG8="
+      ;  false.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+chars_base64(Cs, Bs, Options) :-
+        must_be(list, Options),
+        (   member(O, Options), var(O) ->
+            instantiation_error(chars_base64/3)
+        ;   (   member(padding(Padding), Options) -> true
+            ;   Padding = true
+            ),
+            (   member(charset(Charset), Options) -> true
+            ;   Charset = standard
+            )
+        ),
+        must_be(boolean, Padding),
+        must_be(atom, Charset),
+        (   member(Charset, [standard,url]) -> true
+        ;   domain_error(charset, Charset, chars_base64/3)
+        ),
+        (   var(Cs) ->
+            must_be(list, Bs),
+            maplist(must_be(character), Bs),
+            '$chars_base64'(Cs, Bs, Padding, Charset)
+        ;   must_be(list, Cs),
+            maplist(must_be(character), Cs),
+            '$chars_base64'(Cs, Bs, Padding, Charset)
+        ).

src/lib/clpb.pl

@@ -31,9 +31,10 @@
 :- use_module(library(atts)).
 :- use_module(library(lists)).
 :- use_module(library(iso_ext)).
+:- use_module(library(random)).
 :- use_module(library(pairs)).
 :- use_module(library(dcgs)).
-:- use_module(library(error), []).
+:- use_module(library(error), [domain_error/3, type_error/3]).
 
 :- attribute
         clpb/1,
@@ -97,16 +98,10 @@ instantiation_error(_, Goal-Arg) :-
 domain_error(Expectation, Term) :-
         domain_error(Expectation, Term, unknown(Term)-1).
 
-domain_error(Expectation, Term, Goal-Arg) :-
-        throw(error(domain_error(Expectation, Term), domain_error(Goal, Arg, Expectation, Term))).
-
 
 type_error(Expectation, Term) :-
         type_error(Expectation, Term, unknown(Term)-1).
 
-type_error(Expectation, Term, Goal-Arg) :-
-        throw(error(type_error(Expectation, Term), type_error(Goal, Arg, Expectation, Term))).
-
 partition(Pred, Ls0, As, Bs) :-
         include(Pred, Ls0, As),
         exclude(Pred, Ls0, Bs).

src/lib/clpz.pl

@@ -1,11 +1,11 @@
-/*  CLP(Z): Constraint Logic Programming over Integers.
+/*  CLP(ℤ): Constraint Logic Programming over Integers.
 
     Author:        Markus Triska
     E-mail:        triska@metalevel.at
     WWW:           https://www.metalevel.at
     Copyright (C): 2016-2020 Markus Triska
 
-    This library provides CLP(Z):
+    This library provides CLP(ℤ):
 
               Constraint Logic Programming over Integers
               ==========================================
@@ -115,7 +115,7 @@
 :- use_module(library(iso_ext)).
 :- use_module(library(dcgs)).
 :- use_module(library(terms)).
-:- use_module(library(error), []).
+:- use_module(library(error), [domain_error/3, type_error/3]).
 :- use_module(library(si)).
 :- use_module(library(freeze)).
 
@@ -185,16 +185,9 @@ instantiation_error(_, Goal-Arg) :-
 domain_error(Expectation, Term) :-
         domain_error(Expectation, Term, unknown(Term)-1).
 
-domain_error(Expectation, Term, Goal-Arg) :-
-        throw(error(domain_error(Expectation, Term), domain_error(Goal, Arg, Expectation, Term))).
-
-
 type_error(Expectation, Term) :-
         type_error(Expectation, Term, unknown(Term)-1).
 
-type_error(Expectation, Term, Goal-Arg) :-
-        throw(error(type_error(Expectation, Term), type_error(Goal, Arg, Expectation, Term))).
-
 
 partition(Pred, Ls0, As, Bs) :-
         include(Pred, Ls0, As),
@@ -281,15 +274,15 @@ exclude_([L|Ls0], Goal, Ls) :-
 
 ## Introduction			{#clpz-intro}
 
-This library provides CLP(Z): Constraint Logic Programming over
+This library provides CLP(ℤ): Constraint Logic Programming over
 Integers.
 
-CLP(Z) is an instance of the general CLP(.) scheme, extending logic
-programming with reasoning over specialised domains. CLP(Z) lets us
+CLP(ℤ) is an instance of the general CLP(.) scheme, extending logic
+programming with reasoning over specialised domains. CLP(ℤ) lets us
 reason about **integers** in a way that honors the relational nature
 of Prolog.
 
-There are two major use cases of CLP(Z) constraints:
+There are two major use cases of CLP(ℤ) constraints:
 
     1. [**declarative integer arithmetic**](<#clpz-integer-arith>)
     2. solving **combinatorial problems** such as planning, scheduling
@@ -307,7 +300,7 @@ The predicates of this library can be classified as:
 In most cases, [_arithmetic constraints_](<#clpz-arith-constraints>)
 are the only predicates you will ever need from this library. When
 reasoning over integers, simply replace low-level arithmetic
-predicates like `(is)/2` and `(>)/2` by the corresponding CLP(Z)
+predicates like `(is)/2` and `(>)/2` by the corresponding CLP(ℤ)
 constraints like #=/2 and #>/2 to honor and preserve declarative
 properties of your programs. For satisfactory performance, arithmetic
 constraints are implicitly rewritten at compilation time so that
@@ -315,7 +308,7 @@ low-level fallback predicates are automatically used whenever
 possible.
 
 Almost all Prolog programs also reason about integers. Therefore, it
-is highly advisable that you make CLP(Z) constraints available in all
+is highly advisable that you make CLP(ℤ) constraints available in all
 your programs. One way to do this is to put the following directive in
 your =|~/.swiplrc|= initialisation file:
 
@@ -323,7 +316,7 @@ your =|~/.swiplrc|= initialisation file:
 :- use_module(library(clpz)).
 ==
 
-All example programs that appear in the CLP(Z) documentation assume
+All example programs that appear in the CLP(ℤ) documentation assume
 that you have done this.
 
 Important concepts and principles of this library are illustrated by
@@ -331,7 +324,7 @@ means of usage examples that are available in a public git repository:
 [**github.com/triska/clpz**](https://github.com/triska/clpz)
 
 If you are used to the complicated operational considerations that
-low-level arithmetic primitives necessitate, then moving to CLP(Z)
+low-level arithmetic primitives necessitate, then moving to CLP(ℤ)
 constraints may, due to their power and convenience, at first feel to
 you excessive and almost like cheating. It _isn't_. Constraints are an
 integral part of all popular Prolog systems, and they are designed
@@ -339,7 +332,7 @@ to help you eliminate and avoid the use of low-level and less general
 primitives by providing declarative alternatives that are meant to be
 used instead.
 
-When teaching Prolog, CLP(Z) constraints should be introduced
+When teaching Prolog, CLP(ℤ) constraints should be introduced
 _before_ explaining low-level arithmetic predicates and their
 procedural idiosyncrasies. This is because constraints are easy to
 explain, understand and use due to their purely relational nature. In
@@ -347,13 +340,13 @@ contrast, the modedness and directionality of low-level arithmetic
 primitives are impure limitations that are better deferred to more
 advanced lectures.
 
-More information about CLP(Z) constraints and their implementation is
+More information about CLP(ℤ) constraints and their implementation is
 contained in: [**metalevel.at/drt.pdf**](https://www.metalevel.at/drt.pdf)
 
-The best way to discuss applying, improving and extending CLP(Z)
+The best way to discuss applying, improving and extending CLP(ℤ)
 constraints is to use the dedicated `clpz` tag on
 [stackoverflow.com](http://stackoverflow.com). Several of the world's
-foremost CLP(Z) experts regularly participate in these discussions
+foremost CLP(ℤ) experts regularly participate in these discussions
 and will help you for free on this platform.
 
 ## Arithmetic constraints		{#clpz-arith-constraints}
@@ -408,7 +401,7 @@ etc. are meant to be used _instead_ of the primitives `(is)/2`,
 `(=:=)/2`, `(>)/2` etc. over integers. Almost all Prolog programs also
 reason about integers. Therefore, it is recommended that you put the
 following directive in your =|~/.swiplrc|= initialisation file to make
-CLP(Z) constraints available in all your programs:
+CLP(ℤ) constraints available in all your programs:
 
 ==
 :- use_module(library(clpz)).
@@ -416,7 +409,7 @@ CLP(Z) constraints available in all your programs:
 
 Throughout the following, it is assumed that you have done this.
 
-The most basic use of CLP(Z) constraints is _evaluation_ of
+The most basic use of CLP(ℤ) constraints is _evaluation_ of
 arithmetic expressions involving integers. For example:
 
 ==
@@ -435,7 +428,7 @@ partially instantiated. For example:
 Y = 1.
 ==
 
-This relational nature makes CLP(Z) constraints easy to explain and
+This relational nature makes CLP(ℤ) constraints easy to explain and
 use, and well suited for beginners and experienced Prolog programmers
 alike. In contrast, when using low-level integer arithmetic, we get:
 
@@ -451,7 +444,7 @@ Due to the necessary operational considerations, the use of these
 low-level arithmetic predicates is considerably harder to understand
 and should therefore be deferred to more advanced lectures.
 
-For supported expressions, CLP(Z) constraints are drop-in
+For supported expressions, CLP(ℤ) constraints are drop-in
 replacements of these low-level arithmetic predicates, often yielding
 more general programs. See [`n_factorial/2`](<#clpz-factorial>) for an
 example.
@@ -475,13 +468,13 @@ positive_integer(N) :-
         ).
 ==
 
-This illustrates why the performance of CLP(Z) constraints is almost
+This illustrates why the performance of CLP(ℤ) constraints is almost
 always completely satisfactory when they are used in modes that can be
 handled by low-level arithmetic. To disable the automatic rewriting,
 set the Prolog flag `clpz_goal_expansion` to `false`.
 
 If you are used to the complicated operational considerations that
-low-level arithmetic primitives necessitate, then moving to CLP(Z)
+low-level arithmetic primitives necessitate, then moving to CLP(ℤ)
 constraints may, due to their power and convenience, at first feel to
 you excessive and almost like cheating. It _isn't_. Constraints are an
 integral part of all popular Prolog systems, and they are designed
@@ -507,9 +500,9 @@ n_factorial(N, F) :-
         F #= N * F1.
 ==
 
-This program uses CLP(Z) constraints _instead_ of low-level
+This program uses CLP(ℤ) constraints _instead_ of low-level
 arithmetic throughout, and everything that _would have worked_ with
-low-level arithmetic _also_ works with CLP(Z) constraints, retaining
+low-level arithmetic _also_ works with CLP(ℤ) constraints, retaining
 roughly the same performance. For example:
 
 ==
@@ -519,7 +512,7 @@ false.
 ==
 
 Now the point: Due to the increased flexibility and generality of
-CLP(Z) constraints, we are free to _reorder_ the goals as follows:
+CLP(ℤ) constraints, we are free to _reorder_ the goals as follows:
 
 ==
 n_factorial(0, 1).
@@ -548,18 +541,18 @@ the (implied) constraint `F #\= 0` before the recursive call.
 Otherwise, the query `n_factorial(N, 0)` is the only non-terminating
 case of this kind.
 
-The value of CLP(Z) constraints does _not_ lie in completely freeing
+The value of CLP(ℤ) constraints does _not_ lie in completely freeing
 us from _all_ procedural phenomena. For example, the two programs do
 not even have the same _termination properties_ in all cases.
-Instead, the primary benefit of CLP(Z) constraints is that they allow
+Instead, the primary benefit of CLP(ℤ) constraints is that they allow
 you to try different execution orders and apply [**declarative
 debugging**](https://www.metalevel.at/prolog/debugging.html)
 techniques _at all_!  Reordering goals (and clauses) can significantly
 impact the performance of Prolog programs, and you are free to try
 different variants if you use declarative approaches. Moreover, since
-all CLP(Z) constraints _always terminate_, placing them earlier can
+all CLP(ℤ) constraints _always terminate_, placing them earlier can
 at most _improve_, never worsen, the termination properties of your
-programs. An additional benefit of CLP(Z) constraints is that they
+programs. An additional benefit of CLP(ℤ) constraints is that they
 eliminate the complexity of introducing `(is)/2` and `(=:=)/2` to
 beginners, since _both_ predicates are subsumed by #=/2 when reasoning
 over integers.
@@ -567,7 +560,7 @@ over integers.
 ## Combinatorial constraints  {#clpz-combinatorial}
 
 In addition to subsuming and replacing low-level arithmetic
-predicates, CLP(Z) constraints are often used to solve combinatorial
+predicates, CLP(ℤ) constraints are often used to solve combinatorial
 problems such as planning, scheduling and allocation tasks. Among the
 most frequently used *combinatorial constraints* are all_distinct/1,
 global_cardinality/2 and cumulative/2. This library also provides
@@ -576,12 +569,12 @@ useful in more specialized applications.
 
 ## Domains                             {#clpz-domains}
 
-Each CLP(Z) variable has an associated set of admissible integers,
+Each CLP(ℤ) variable has an associated set of admissible integers,
 which we call the variable's *domain*. Initially, the domain of each
-CLP(Z) variable is the set of _all_ integers. CLP(Z) constraints
+CLP(ℤ) variable is the set of _all_ integers. CLP(ℤ) constraints
 like #=/2, #>/2 and #\=/2 can at most reduce, and never extend, the
 domains of their arguments. The constraints in/2 and ins/2 let us
-explicitly state domains of CLP(Z) variables. The process of
+explicitly state domains of CLP(ℤ) variables. The process of
 determining and adjusting domains of variables is called constraint
 *propagation*, and it is performed automatically by this library. When
 the domain of a variable contains only one element, then the variable
@@ -593,7 +586,7 @@ and by enumeration predicates like labeling/2.
 ## Example: Sudoku {#clpz-sudoku}
 
 As another example, consider _Sudoku_: It is a popular puzzle
-over integers that can be easily solved with CLP(Z) constraints.
+over integers that can be easily solved with CLP(ℤ) constraints.
 
 ==
 sudoku(Rows) :-
@@ -697,7 +690,7 @@ own labeling strategies.
 
 ## Core relations and search    {#clpz-search}
 
-Using CLP(Z) constraints to solve combinatorial tasks typically
+Using CLP(ℤ) constraints to solve combinatorial tasks typically
 consists of two phases:
 
     1. First, all relevant constraints are stated.
@@ -713,7 +706,7 @@ search, and more easily try different search strategies.
 
 As an example of a constraint satisfaction problem, consider the
 cryptoarithmetic puzzle SEND + MORE = MONEY, where different letters
-denote distinct integers between 0 and 9. It can be modeled in CLP(Z)
+denote distinct integers between 0 and 9. It can be modeled in CLP(ℤ)
 as follows:
 
 ==
@@ -776,13 +769,13 @@ so-called _eight queens puzzle_. The task is to place 8 queens on an
 8x8 chessboard such that none of the queens is under attack. This
 means that no two queens share the same row, column or diagonal.
 
-To express this puzzle via CLP(Z) constraints, we must first pick a
-suitable representation. Since CLP(Z) constraints reason over
+To express this puzzle via CLP(ℤ) constraints, we must first pick a
+suitable representation. Since CLP(ℤ) constraints reason over
 _integers_, we must find a way to map the positions of queens to
 integers. Several such mappings are conceivable, and it is not
 immediately obvious which we should use. On top of that, different
 constraints can be used to express the desired relations. For such
-reasons, _modeling_ combinatorial problems via CLP(Z) constraints
+reasons, _modeling_ combinatorial problems via CLP(ℤ) constraints
 often necessitates some creativity and has been described as more of
 an art than a science.
 
@@ -847,7 +840,7 @@ separated the core relation from the actual search.
 
 ## Optimisation    {#clpz-optimisation}
 
-We can use labeling/2 to minimize or maximize the value of a CLP(Z)
+We can use labeling/2 to minimize or maximize the value of a CLP(ℤ)
 expression, and generate solutions in increasing or decreasing order
 of the value. See the labeling options `min(Expr)` and `max(Expr)`,
 respectively.
@@ -864,9 +857,9 @@ solutions that are _also_ optimal, so that we can choose among optimal
 solutions by other criteria. For the sake of
 [**purity**](https://www.metalevel.at/prolog/purity.html) and
 completeness, we recommend to avoid `once/1` and other constructs that
-lead to impurities in CLP(Z) programs.
+lead to impurities in CLP(ℤ) programs.
 
-Related to optimisation with CLP(Z) constraints are `library(simplex)`
+Related to optimisation with CLP(ℤ) constraints are `library(simplex)`
 and CLP(Q) which reason about _linear_ constraints over rational
 numbers.
 
@@ -890,9 +883,9 @@ The constraints of this table are reifiable as well.
 When reasoning over Boolean variables, also consider using CLP(B)
 constraints as provided by `library(clpb)`.
 
-## Enabling monotonic CLP(Z)		{#clpz-monotonicity}
+## Enabling monotonic CLP(ℤ)		{#clpz-monotonicity}
 
-In the default execution mode, CLP(Z) constraints still exhibit some
+In the default execution mode, CLP(ℤ) constraints still exhibit some
 non-relational properties. For example, _adding_ constraints can yield
 new solutions:
 
@@ -907,7 +900,7 @@ X = 1+1.
 This behaviour is highly problematic from a logical point of view, and
 it may render declarative debugging techniques inapplicable.
 
-Assert `clpz:monotonic` to make CLP(Z) **monotonic**: This means
+Assert `clpz:monotonic` to make CLP(ℤ) **monotonic**: This means
 that _adding_ new constraints _cannot_ yield new solutions. When this
 flag is `true`, we must wrap variables that occur in arithmetic
 expressions with the functor `(?)/1` or `(#)/1`. For example:
@@ -2516,7 +2509,7 @@ remove_lower([C*X|CXs], Min) :-
 
 
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-   Parsing a CLP(Z) expression has two important side-effects: First,
+   Parsing a CLP(ℤ) expression has two important side-effects: First,
    it constrains the variables occurring in the expression to
    integers. Second, it constrains some of them even more: For
    example, in X/Y and X mod Y, Y is constrained to be #\= 0.
@@ -2954,7 +2947,7 @@ expr_conds(A0 mod B0, A mod B)   -->
 expr_conds(A0^B0, A^B)           -->
         expr_conds(A0, A), expr_conds(B0, B),
         [(B >= 0 ; A =:= -1)].
-% Bitwise operations, added to make CLP(Z) usable in more cases
+% Bitwise operations, added to make CLP(ℤ) usable in more cases
 expr_conds(\ A0, \ A) --> expr_conds(A0, A).
 expr_conds(A0<<B0, A<<B) --> expr_conds(A0, A), expr_conds(B0, B).
 expr_conds(A0>>B0, A>>B) --> expr_conds(A0, A), expr_conds(B0, B).
@@ -3045,13 +3038,13 @@ expansion_simpler((A0,B0), (A,B)) :- !,
 expansion_simpler(Var is Expr0, Goal) :-
         ground(Expr0), !,
         phrase(expr_conds(Expr0, Expr), Gs),
-        (   maplist(call, Gs) -> Var is Expr, Goal = true
+        (   maplist(call, Gs) -> Value is Expr, Goal = (Var = Value)
         ;   Goal = false
         ).
 expansion_simpler(Var =:= Expr0, Goal) :-
         ground(Expr0), !,
         phrase(expr_conds(Expr0, Expr), Gs),
-        (   maplist(call, Gs) -> Goal = (Var =:= Expr)
+        (   maplist(call, Gs) -> Value is Expr, Goal = (Var =:= Value)
         ;   Goal = false
         ).
 expansion_simpler(between(L,U,V), Goal) :- maplist(integer, [L,U,V]), !,
@@ -3071,10 +3064,12 @@ is_false(var(X)) :- nonvar(X).
 
 :- dynamic(goal_expansion/1).
 
-goal_expansion(Goal0, _Layout1, _Module, Goal, []) :-
-        \+ goal_expansion(false),
-        clpz_expandable(Goal0),
-        clpz_expansion(Goal0, Goal).
+% goal expansion is disabled for now, until #445 is resolved
+%
+% user:goal_expansion(Goal0, Goal) :-
+%         \+ goal_expansion(false),
+%         clpz_expandable(Goal0),
+%         clpz_expansion(Goal0, Goal).
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -6924,12 +6919,6 @@ contribution_at(T, Task, Offset-Bs, Contribution) :-
             ?(Contribution) #= B*C
         ).
 
-nth0(0, [E|_], E) :- !.
-nth0(N, [_|Ls], E) :-
-        N > 0,
-        N1 is N - 1,
-        nth0(N1, Ls, E).
-
 nth1(I, Es, E) :-
         I0 is I-1,
         nth0(I0, Es, E).
@@ -7272,7 +7261,7 @@ chain(Relation, X, Prev, X) :- call(Relation, ?(Prev), ?(X)).
 
 %% fd_var(+Var)
 %
-%  True iff Var is a CLP(Z) variable.
+%  True iff Var is a CLP(ℤ) variable.
 
 fd_var(X) :- get_attr(X, clpz, _).
 
@@ -7384,7 +7373,8 @@ goals_entail(Goals, E) :-
 
 verify_attributes(Var, Other, Gs) :-
         % portray_clause(Var = Other),
-        (   get_attr(Var, clpz, clpz_attr(_,_,_,Dom,Ps,Q)) ->
+        (   get_atts(Var, clpz(CLPZ)) ->
+            CLPZ = clpz_attr(_,_,_,Dom,Ps,Q),
             (   nonvar(Other) ->
                 (   integer(Other) -> true
                 ;   type_error(integer, Other)
@@ -7392,14 +7382,17 @@ verify_attributes(Var, Other, Gs) :-
                 domain_contains(Dom, Other),
                 phrase(trigger_props(Ps), [Q], [_]),
                 Gs = [phrase(do_queue, [Q], _)]
-            ;   fd_get(Other, OD, OPs),
-                domains_intersection(OD, Dom, Dom1),
-                append_propagators(Ps, OPs, Ps1),
-                new_queue(Q0),
-                variables_same_queue([Var,Other]),
-                phrase((fd_put(Other,Dom1,Ps1),
-                        trigger_props(Ps1)), [Q0], _),
-                Gs = [phrase(do_queue, [Q0], _)]
+            ;   (   get_atts(Other, clpz(clpz_attr(_,_,_,OD,OPs,_))) ->
+                    domains_intersection(OD, Dom, Dom1),
+                    append_propagators(Ps, OPs, Ps1),
+                    new_queue(Q0),
+                    variables_same_queue([Var,Other]),
+                    phrase((fd_put(Other,Dom1,Ps1),
+                            trigger_props(Ps1)), [Q0], _),
+                    Gs = [phrase(do_queue, [Q0], _)]
+                ;   put_atts(Other, clpz(CLPZ)),
+                    Gs = []
+                )
             )
         ;   Gs = []
         ).
@@ -7433,6 +7426,10 @@ intervals_to_drep([A0-B0|Rest], Drep0, Drep) :-
         ),
         intervals_to_drep(Rest, Drep0 \/ D1, Drep).
 
+attribute_goals(X) -->
+        { get_atts(X, queue(_,_)) },
+        !,
+        { put_atts(X, -queue(_,_)) }.
 attribute_goals(X) -->
         % { get_attr(X, clpz, Attr), format("A: ~w\n", [Attr]) },
         { get_attr(X, clpz, clpz_attr(_,_,_,Dom,fd_props(Gs,Bs,Os),_)),

src/lib/cont.pl

@@ -10,7 +10,7 @@ shift(Ball) :-
     '$nextEP'(first, E, P),
     get_chunks(E, P, L),
     (  L == [] ->
-       Cont = none
+       Cont = cont(true)
     ;  Cont = cont(call_continuation(L))
     ),
     '$write_cont_and_term'(_, _, Cont, Ball),

src/lib/crypto.pl

@@ -0,0 +1,826 @@
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Written May 2020 by Markus Triska (triska@metalevel.at)
+   Part of Scryer Prolog.
+
+   Predicates for cryptographic applications.
+
+   This library assumes that the Prolog flag double_quotes is set to chars.
+   In Scryer Prolog, lists of characters are very efficiently represented,
+   and strings have the advantage that the atom table remains unmodified.
+
+   Especially for cryptographic applications, it as an advantage that
+   using strings leaves little trace of what was processed in the system.
+
+   For predicates that accept an encoding/1 option to specify the encoding
+   of the input data, if encoding(octet) is used, then the input can also
+   be specified as a list of bytes, i.e., integers between 0 and 255.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+:- module(crypto,
+          [hex_bytes/2,                  % ?Hex, ?Bytes
+           crypto_n_random_bytes/2,      % +N, -Bytes
+           crypto_data_hash/3,           % +Data, -Hash, +Options
+           crypto_data_hkdf/4,           % +Data, +Length, -Bytes, +Options
+           crypto_password_hash/2,       % +Password, ?Hash
+           crypto_password_hash/3,       % +Password, -Hash, +Options
+           crypto_data_encrypt/6,        % +PlainText, +Algorithm, +Key, +IV, -CipherText, +Options
+           crypto_data_decrypt/6,        % +CipherText, +Algorithm, +Key, +IV, -PlainText, +Options
+           ed25519_new_keypair/1,        % -KeyPair
+           ed25519_keypair_public_key/2, % +KeyPair, +PublicKey
+           ed25519_sign/4,               % +KeyPair, +Data, -Signature, +Options
+           ed25519_verify/4,             % +PublicKey, +Data, +Signature, +Options
+           curve25519_generator/1,       % -Generator
+           curve25519_scalar_mult/3,     % +Scalar, +Point, -Result
+           crypto_name_curve/2,          % +Name, -Curve
+           crypto_curve_order/2,         % +Curve, -Order
+           crypto_curve_generator/2,     % +Curve, -Generator
+           crypto_curve_scalar_mult/4    % +Curve, +Scalar, +Point, -Result
+          ]).
+
+:- use_module(library(error)).
+:- use_module(library(lists)).
+:- use_module(library(between)).
+:- use_module(library(dcgs)).
+:- use_module(library(clpz)).
+:- use_module(library(arithmetic)).
+:- use_module(library(format)).
+:- use_module(library(charsio)).
+:- use_module(library(si)).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   hex_bytes(?Hex, ?Bytes) is det.
+
+   Relation between a hexadecimal sequence and a list of bytes. Hex
+   is a string of hexadecimal numbers. Bytes is a list of *integers*
+   between 0 and 255 that represent the sequence as a list of bytes.
+   At least one of the arguments must be instantiated.
+
+   Example:
+
+   ?- hex_bytes("501ACE", Bs).
+      Bs = [80,26,206]
+   ;  false.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+
+hex_bytes(Hs, Bytes) :-
+        (   ground(Hs) ->
+            must_be(list, Hs),
+            maplist(must_be(atom), Hs),
+            (   phrase(hex_bytes(Hs), Bytes) ->
+                true
+            ;   domain_error(hex_encoding, Hs, hex_bytes/2)
+            )
+        ;   must_be_bytes(Bytes, hex_bytes/2),
+            phrase(bytes_hex(Bytes), Hs)
+        ).
+
+hex_bytes([]) --> [].
+hex_bytes([H1,H2|Hs]) --> [Byte],
+        { char_hexval(H1, High),
+          char_hexval(H2, Low),
+          Byte #= High*16 + Low },
+        hex_bytes(Hs).
+
+bytes_hex([]) --> [].
+bytes_hex([B|Bs]) --> [C0,C1],
+        { High #= B>>4,
+          Low #= B /\ 0xf,
+          char_hexval(C0, High),
+          char_hexval(C1, Low)
+        },
+        bytes_hex(Bs).
+
+char_hexval(C, H) :- nth0(H, "0123456789abcdef", C), !.
+char_hexval(C, H) :- nth0(H, "0123456789ABCDEF", C), !.
+
+
+must_be_bytes(Bytes, Context) :-
+        must_be(list, Bytes),
+        maplist(must_be(integer), Bytes),
+        (   member(B, Bytes), \+ between(0, 255, B) ->
+            type_error(byte, B, Context)
+        ;   true
+        ).
+
+
+must_be_byte_chars(Chars, Context) :-
+        must_be(list, Chars),
+        (   member(Char, Chars),
+            char_code(Char, Code),
+            \+ between(0, 255, Code) ->
+            domain_error(byte_char, Char, Context)
+        ;   true
+        ).
+
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Cryptographically secure random numbers
+   =======================================
+
+   crypto_n_random_bytes(+N, -Bytes) is det
+
+   Bytes is unified with a list of N cryptographically secure
+   pseudo-random bytes. Each byte is an integer between 0 and 255. If
+   the internal pseudo-random number generator (PRNG) has not been
+   seeded with enough entropy to ensure an unpredictable byte
+   sequence, an exception is thrown.
+
+   One way to relate such a list of bytes to an _integer_ is to use
+   CLP(ℤ) constraints as follows:
+
+   :- use_module(library(clpz)).
+   :- use_module(library(lists)).
+
+   bytes_integer(Bs, N) :-
+           foldl(pow, Bs, 0-0, N-_).
+
+   pow(B, N0-I0, N-I) :-
+           B in 0..255,
+           N #= N0 + B*256^I0,
+           I #= I0 + 1.
+
+   With this definition, we can generate a random 256-bit integer
+   _from_ a list of 32 random _bytes_:
+
+   ?- crypto_n_random_bytes(32, Bs),
+      bytes_integer(Bs, I).
+      Bs = [146,166,162,210,242,7,25,132,64,94|...],
+      I = 337420085690608915485...(56 digits omitted)
+
+   The above relation also works in the other direction, letting you
+   translate an integer _to_ a list of bytes. In addition, you can
+   use hex_bytes/2 to convert bytes to _tokens_ that can be easily
+   exchanged in your applications.
+
+   ?- crypto_n_random_bytes(12, Bs),
+      hex_bytes(Hex, Bs).
+      Bs = [34,25,50,72,58,63,50,172,32,46|...], Hex = "221932483a3f32ac202 ..."
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+
+crypto_n_random_bytes(N, Bs) :-
+        must_be(integer, N),
+        length(Bs, N),
+        maplist(crypto_random_byte, Bs).
+
+crypto_random_byte(B) :- '$crypto_random_byte'(B).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Hashing
+   =======
+
+   crypto_data_hash(+Data, -Hash, +Options)
+
+   Where Data is a list of characters, and Hash is the computed hash
+   as a list of hexadecimal characters.
+
+   Options is a list of:
+
+     - algorithm(+A)
+       where A is one of ripemd160, sha256, sha384, sha512, sha512_256,
+       sha3_224, sha3_256, sha3_384, sha3_512, blake2s256, blake2b512,
+       or a variable. If A is a variable, then it is unified with the
+       default algorithm, which is an algorithm that is considered
+       cryptographically secure at the time of this writing.
+     - encoding(+Encoding)
+       The default encoding is utf8. The alternative is octet,
+       to treat the input as a list of raw bytes.
+
+   Example:
+
+   ?- crypto_data_hash("abc", Hs, [algorithm(sha256)]).
+      Hs = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+   ;  false.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   SHA256 is the current default for several hash-related predicates.
+   It is deemed sufficiently secure for the foreseeable future.  Yet,
+   application programmers must be aware that the default may change in
+   future versions. The hash predicates all yield the algorithm they
+   used if a Prolog variable is used for the pertaining option.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+crypto_data_hash(Data0, Hash, Options0) :-
+        must_be(list, Options0),
+        options_data_chars(Options0, Data0, Data, Encoding),
+        functor_hash_options(algorithm, A, Options0, _),
+        (   hash_algorithm(A) -> true
+        ;   domain_error(hash_algorithm, A, crypto_data_hash/3)
+        ),
+        '$crypto_data_hash'(Data, Encoding, HashBytes, A),
+        hex_bytes(Hash, HashBytes).
+
+options_data_chars(Options, Data, Chars, Encoding) :-
+        option(encoding(Encoding), Options, utf8),
+        must_be(atom, Encoding),
+        encoding_chars(Encoding, Data, Chars).
+
+default_hash(sha256).
+
+functor_hash_options(F, Hash, Options0, [Option|Options]) :-
+        Option =.. [F,Hash],
+        (   select(Option, Options0, Options) ->
+            (   var(Hash) ->
+                default_hash(Hash)
+            ;   must_be(atom, Hash)
+            )
+        ;   Options = Options0,
+            default_hash(Hash)
+        ).
+
+hash_algorithm(ripemd160).
+hash_algorithm(sha256).
+hash_algorithm(sha512).
+hash_algorithm(sha384).
+hash_algorithm(sha512_256).
+hash_algorithm(sha3_224).
+hash_algorithm(sha3_256).
+hash_algorithm(sha3_384).
+hash_algorithm(sha3_512).
+hash_algorithm(blake2s256).
+hash_algorithm(blake2b512).
+
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   crypto_data_hkdf(+Data, +Length, -Bytes, +Options) is det.
+
+   Concentrate possibly dispersed entropy of Data and then expand it
+   to the desired length. Data is a list of characters.
+
+   Bytes is unified with a list of bytes of length Length, and is
+   suitable as input keying material and initialization vectors to
+   symmetric encryption algorithms.
+
+   Admissible options are:
+
+     - algorithm(+Algorithm)
+       One of sha256, sha384 or sha512. If you specify a variable,
+       then it is unified with the algorithm that was used, which is a
+       cryptographically secure algorithm by default.
+     - info(+Info)
+       Optional context and application specific information,
+       specified as a list of characters. The default is [].
+     - salt(+List)
+       Optionally, a list of bytes that are used as salt. The
+       default is all zeroes.
+     - encoding(+Encoding)
+       The default encoding is utf8. The alternative is octet,
+       to treat the input as a list of raw bytes.
+
+   The `info/1`  option can be  used to  generate multiple keys  from a
+   single  master key,  using for  example values  such as  "key" and
+   "iv", or the name of a file that is to be encrypted.
+
+   See crypto_n_random_bytes/2 to obtain a suitable salt.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+crypto_data_hkdf(Data0, L, Bytes, Options0) :-
+        functor_hash_options(algorithm, Algorithm, Options0, Options),
+        (   hkdf_algorithm(Algorithm) -> true
+        ;   domain_error(hkdf_algorithm, Algorithm, crypto_data_hkdf/4)
+        ),
+        must_be(integer, L),
+        L >= 0,
+        options_data_chars(Options, Data0, Data, Encoding),
+        option(salt(SaltBytes), Options, []),
+        must_be_bytes(SaltBytes, crypto_data_hkdf/4),
+        option(info(Info0), Options, []),
+        chars_bytes_(Info0, Info, crypto_data_hkdf/4),
+        '$crypto_data_hkdf'(Data, Encoding, SaltBytes, Info, Algorithm, L, Bytes).
+
+hkdf_algorithm(sha256).
+hkdf_algorithm(sha384).
+hkdf_algorithm(sha512).
+
+option(What, Options, Default) :-
+        (   member(V, Options), var(V) ->
+            instantiation_error(option/3)
+        ;   true
+        ),
+        (   member(What, Options) -> true
+        ;   What =.. [_,Default]
+        ).
+
+chars_bytes_(Cs, Bytes, Context) :-
+        must_be(list, Cs),
+        (   maplist(integer, Cs) -> Bytes = Cs
+        ;   chars_utf8bytes(Cs, Bytes)
+        ),
+        must_be_bytes(Bytes, Context).
+
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   The so-called modular crypt format (MCF) is a standard for encoding
+   password hash strings. However, there's no official specification
+   document describing it. Nor is there a central registry of
+   identifiers or rules. This page describes what is known about it:
+
+   https://pythonhosted.org/passlib/modular_crypt_format.html
+
+   As of 2016, the MCF is deprecated in favor of the PHC String Format:
+
+   https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md
+
+   This is what we are using below. For the time being, it is best to
+   treat these hashes as opaque terms in applications. Please let me
+   know if you need to rely on any specifics of this format.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   crypto_password_hash(+Password, ?Hash) is semidet.
+
+   If Hash is instantiated, the predicate succeeds _iff_ the hash
+   matches the given password. Otherwise, the call is equivalent to
+   crypto_password_hash(Password, Hash, []) and computes a
+   password-based hash using the default options.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+crypto_password_hash(Password0, Hash) :-
+        (   nonvar(Hash) ->
+            chars_bytes_(Password0, Password, crypto_password_hash/2),
+            must_be(list, Hash),
+            dollar_segments(Hash, [[],"pbkdf2-sha512",[t,=|CsIterations],SaltB64,HashB64]),
+            number_chars(Iterations, CsIterations),
+            bytes_base64(SaltBytes, SaltB64),
+            bytes_base64(HashBytes, HashB64),
+            '$crypto_password_hash'(Password, SaltBytes, Iterations, HashBytes)
+        ;   crypto_password_hash(Password0, Hash, [])
+        ).
+
+
+dollar_segments(Ls, Segments) :-
+        (   append(Front, [$|Ds], Ls) ->
+            Segments = [Front|Rest],
+            dollar_segments(Ds, Rest)
+        ;   Segments = [Ls]
+        ).
+
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   crypto_password_hash(+Password, -Hash, +Options) is det.
+
+   Derive Hash based on Password. This predicate is similar to
+   crypto_data_hash/3 in that it derives a hash from given data.
+   However, it is tailored for the specific use case of _passwords_.
+   One essential distinction is that for this use case, the derivation
+   of a hash should be _as slow as possible_ to counteract brute-force
+   attacks over possible passwords.
+
+   Another important distinction is that equal passwords must yield,
+   with very high probability, _different_ hashes. For this reason,
+   cryptographically strong random numbers are automatically added to
+   the password before a hash is derived.
+
+   Hash is unified with a string that contains the computed hash and
+   all parameters that were used, except for the password. Instead of
+   storing passwords, store these hashes. Later, you can verify the
+   validity of a password with crypto_password_hash/2, comparing the
+   then entered password to the stored hash. If you need to export this
+   atom, you should treat it as opaque ASCII data with up to 255 bytes
+   of length. The maximal length may increase in the future.
+
+   Admissible options are:
+
+     - algorithm(+Algorithm)
+       The algorithm to use. Currently, the only available algorithm
+       is 'pbkdf2-sha512', which is therefore also the default.
+     - cost(+C)
+       C is an integer, denoting the binary logarithm of the number
+       of _iterations_ used for the derivation of the hash. This
+       means that the number of iterations is set to 2^C. Currently,
+       the default is 17, and thus more than one hundred _thousand_
+       iterations. You should set this option as high as your server
+       and users can tolerate. The default is subject to change and
+       will likely increase in the future or adapt to new algorithms.
+     - salt(+Salt)
+       Use the given list of bytes as salt. By default,
+       cryptographically secure random numbers are generated for this
+       purpose. The default is intended to be secure, and constitutes
+       the typical use case of this predicate.
+
+   Currently, PBKDF2 with SHA-512 is used as the hash derivation
+   function, using 128 bits of salt. All default parameters, including
+   the algorithm, are subject to change, and other algorithms will also
+   become available in the future. Since computed hashes store all
+   parameters that were used during their derivation, such changes will
+   not affect the operation of existing deployments. Note though that
+   new hashes will then be computed with the new default parameters.
+
+   See crypto_data_hkdf/4 for generating keys from Hash.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+crypto_password_hash(Password0, Hash, Options) :-
+        chars_bytes_(Password0, Password, crypto_password_hash/3),
+        must_be(list, Options),
+        option(cost(C), Options, 17),
+        Iterations is 2^C,
+        Algorithm = 'pbkdf2-sha512', % current default and only option
+        option(algorithm(Algorithm), Options, Algorithm),
+        (   member(salt(SaltBytes), Options) ->
+            must_be_bytes(SaltBytes, crypto_password_hash/2)
+        ;   crypto_n_random_bytes(16, SaltBytes)
+        ),
+        '$crypto_password_hash'(Password, SaltBytes, Iterations, HashBytes),
+        bytes_base64(HashBytes, HashB64),
+        bytes_base64(SaltBytes, SaltB64),
+        phrase(format_("$pbkdf2-sha512$t=~d$~s$~s", [Iterations,SaltB64,HashB64]), Hash).
+
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Bidirectional Bytes <-> Base64 conversion *without padding*.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+bytes_base64(Bytes, Base64) :-
+        (   var(Bytes) ->
+            chars_base64(Chars, Base64, [padding(false)]),
+            maplist(char_code, Chars, Bytes)
+        ;   maplist(char_code, Chars, Bytes),
+            chars_base64(Chars, Base64, [padding(false)])
+        ).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   crypto_data_encrypt(+PlainText,
+                       +Algorithm,
+                       +Key,
+                       +IV,
+                       -CipherText,
+                       +Options).
+
+   Encrypt the given PlainText, using the symmetric algorithm
+   Algorithm, key Key, and initialization vector (or nonce) IV, to
+   give CipherText.
+
+   PlainText must be a list of characters, Key and IV must be lists of
+   bytes, and CipherText is created as a list of characters.
+
+   Keys and IVs can be chosen at random (using for example
+   crypto_n_random_bytes/2) or derived from input keying material (IKM)
+   using for example crypto_data_hkdf/4. This input is often a shared
+   secret, such as a negotiated point on an elliptic curve, or the hash
+   that was computed from a password via crypto_password_hash/3 with a
+   freshly generated and specified _salt_.
+
+   Reusing the same combination of Key and IV typically leaks at least
+   _some_ information about the plaintext. For example, identical
+   plaintexts will then correspond to identical ciphertexts. For some
+   algorithms, reusing an IV with the same Key has disastrous results
+   and can cause the loss of all properties that are otherwise
+   guaranteed. Especially in such cases, an IV is also called a
+   _nonce_ (number used once).
+
+   It is safe to store and  transfer the used initialization vector (or
+   nonce) in plain text, but the key _must be kept secret_.
+
+   Currently, the only supported algorithm is 'chacha20-poly1305', a
+   powerful and efficient _authenticated_ encryption scheme, providing
+   secrecy and at the same time reliable protection against undetected
+   _modifications_ of the encrypted data. This is a very good choice
+   for virtually all use cases. It is a stream cipher and can encrypt
+   data of any length up to 256 GB. Further, the encrypted data has
+   exactly the same length as the original, and no padding is used.
+
+   Options:
+
+      - encoding(+Encoding)
+      Encoding to use for PlainText. Default is utf8. The alternative
+      is octet to treat PlainText as raw bytes.
+
+      - tag(-List)
+      For authenticated encryption schemes, List is unified with a
+      list of _bytes_ holding the tag. This tag must be provided for
+      decryption.
+
+   Here is an example encryption and decryption, using the ChaCha20
+   stream cipher with the Poly1305 authenticator. This cipher uses a
+   256-bit key and a 96-bit nonce, i.e., 32 and 12 _bytes_,
+   respectively:
+
+    ?- Algorithm = 'chacha20-poly1305',
+       crypto_n_random_bytes(32, Key),
+       crypto_n_random_bytes(12, IV),
+       crypto_data_encrypt("this text is to be encrypted", Algorithm,
+                   Key, IV, CipherText, [tag(Tag)]),
+       crypto_data_decrypt(CipherText, Algorithm,
+                   Key, IV, RecoveredText, [tag(Tag)]).
+
+   Yielding:
+
+       Algorithm = 'chacha20-poly1305',
+       Key = [113,247,153,134,177,220,13,193,50,150|...],
+       IV = [135,20,149,153,63,35,68,114,247,171|...],
+       CipherText = "\x94\0Ej\x94\®Â\x95\óÑÆXÃn¾ð©b\x1c\ ...",
+       RecoveredText = "this text is to be  ...",
+       Tag = [152,117,152,17,162,75,150,206,144,40|...]
+
+   In this example, we use crypto_n_random_bytes/2 to generate a key
+   and nonce from cryptographically secure random numbers. For
+   repeated applications, you must ensure that a nonce is only used
+   _once_ together with the same key. Note that for _authenticated_
+   encryption schemes, the _tag_ that was computed during encryption
+   is necessary for decryption. It is safe to store and transfer the
+   tag in plain text.
+
+   See also crypto_data_decrypt/6, and hex_bytes/2 for conversion
+   between bytes and hex encoding.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+crypto_data_encrypt(PlainText0, Algorithm, Key, IV, CipherText, Options) :-
+        options_data_chars(Options, PlainText0, PlainText, Encoding),
+        option(tag(Tag), Options, _),
+        (   nonvar(Tag) ->
+            must_be_bytes(Tag, crypto_data_encrypt/6)
+        ;   true
+        ),
+        must_be_bytes(Key, crypto_data_encrypt/6),
+        must_be_bytes(IV, crypto_data_encrypt/6),
+        must_be(atom, Algorithm),
+        (   Algorithm = 'chacha20-poly1305' -> true
+        ;   domain_error('chacha20-poly1305', Algorithm, crypto_data_encrypt/6)
+        ),
+        '$crypto_data_encrypt'(PlainText, Encoding, Key, IV, Tag, CipherText).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  crypto_data_decrypt(+CipherText,
+                      +Algorithm,
+                      +Key,
+                      +IV,
+                      -PlainText,
+                      +Options).
+
+   Decrypt the given CipherText, using the symmetric algorithm
+   Algorithm, key Key, and initialization vector IV, to give
+   PlainText. CipherText must be a list of characters, and Key and IV
+   must be lists of bytes. PlainText is created as a list of
+   characters.
+
+   Currently, the only supported algorithm is 'chacha20-poly1305',
+   a very secure, fast and versatile authenticated encryption method.
+
+   Options is a list of:
+
+    - encoding(+Encoding)
+    Encoding to use for PlainText. The default is utf8. The
+    alternative is octet, which is used if the data are raw bytes.
+
+    - tag(+Tag)
+    For authenticated encryption schemes, the tag must be specified as
+    a list of bytes exactly as they were generated upon encryption.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+crypto_data_decrypt(CipherText0, Algorithm, Key, IV, PlainText, Options) :-
+        option(tag(Tag), Options, []),
+        must_be_bytes(Tag, crypto_data_decrypt/6),
+        must_be_bytes(Key, crypto_data_decrypt/6),
+        must_be_bytes(IV, crypto_data_decrypt/6),
+        must_be(atom, Algorithm),
+        option(encoding(Encoding), Options, utf8),
+        must_be(atom, Encoding),
+        member(Encoding, [utf8,octet]),
+        must_be(list, CipherText0),
+        encoding_chars(octet, CipherText0, CipherText1),
+        maplist(char_code, TagChars, Tag),
+        append(CipherText1, TagChars, CipherText),
+        (   Algorithm = 'chacha20-poly1305' -> true
+        ;   domain_error('chacha20-poly1305', Algorithm, crypto_data_decrypt/6)
+        ),
+        '$crypto_data_decrypt'(CipherText, octet, Key, IV, Encoding, PlainText).
+
+
+encoding_chars(octet, Bs, Cs) :-
+        must_be(list, Bs),
+        (   maplist(integer, Bs) ->
+            maplist(char_code, Cs, Bs)
+        ;   Bs = Cs
+        ),
+        must_be_byte_chars(Cs, crypto_encoding).
+encoding_chars(utf8, Cs, Cs) :-
+        must_be(list, Cs),
+        maplist(must_be(character), Cs).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Digital signatures with Ed25519
+   ===============================
+
+   - ed25519_new_keypair(-Pair)
+     Yields a new Ed25519 key pair Pair, a list of characters. The
+     pair contains the private key and must be kept absolutely secret.
+     Pair can be used for signing. Its public key can be obtained
+     with ed25519_keypair_public_key/2.
+
+   - ed25519_keypair_public_key(+Pair, -PublicKey)
+     PublicKey is the public key of the given key pair. The public key
+     can be used for signature verification, and can be shared freely.
+     The public key is represented as a list of characters.
+
+   - ed25519_sign(+Key, +Data, -Signature, +Options)
+     Key and Data must be lists of characters. Key is a key pair in
+     PKCS#8 v2 format as generated by ed25519_new_keypair/1. Sign Data
+     with Key, yielding Signature as a list of hexadecimal characters.
+
+   - ed25519_verify(+Key, +Data, +Signature, +Options)
+     Key and Data must be lists of characters. Key is a public key.
+     Succeeds if Data was signed with the private key corresponding to
+     Key, where Signature is a list of hexadecimal characters as
+     generated by ed25519_sign/4. Fails otherwise.
+
+   Currently, the only option for signing and verifying is:
+
+     - encoding(+Encoding)
+       The default encoding of Data is utf8. The alternative is octet,
+       which treats Data as a list of raw bytes.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+ed25519_new_keypair(Pair) :-
+        '$ed25519_new_keypair'(Pair).
+
+ed25519_keypair_public_key(Pair, PublicKey) :-
+        must_be_byte_chars(Pair, ed25519_keypair_public_key),
+        '$ed25519_keypair_public_key'(Pair, octet, PublicKey).
+
+ed25519_sign(Key, Data0, Signature, Options) :-
+        must_be_byte_chars(Key, ed25519_sign),
+        options_data_chars(Options, Data0, Data, Encoding),
+        '$ed25519_sign'(Key, octet, Data, Encoding, Signature0),
+        hex_bytes(Signature, Signature0).
+
+ed25519_verify(Key, Data0, Signature0, Options) :-
+        must_be_byte_chars(Key, ed25519_verify),
+        options_data_chars(Options, Data0, Data, Encoding),
+        hex_bytes(Signature0, Signature),
+        '$ed25519_verify'(Key, octet, Data, Encoding, Signature).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   X25519: ECDH key exchange over Curve25519
+   =========================================
+
+   Points on Curve25519 are represented as lists of characters that denote
+   the u-coordinate of the Montgomery curve.
+
+   - curve25519_generator(-Gs)
+     Gs is the generator point of Curve25519.
+
+   - curve25519_scalar_mult(+Scalar, +Ps, -Rs)
+     Scalar must be an integer between 0 and 2^256-1,
+     or a list of 32 bytes, and Ps must be a point on the curve.
+     Computes the point Rs = Scalar*Ps as mandated by X25519.
+
+   Alice and Bob can use this to establish a shared secret as follows,
+   where Gs is the generator point of Curve25519:
+
+     1. Alice creates a random integer a and sends As = a*Gs to Bob.
+     2. Bob creates a random integer b and sends Bs = b*Gs to Alice.
+     3. Alice computes Rs = a*Bs.
+     4. Bob computes Rs = b*As.
+     5. Alice and Bob use crypto_data_hkdf/4 on Rs with suitable
+        (same) parameters to obtain lists of bytes that can be used as
+        keys and initialization vectors for symmetric encryption.
+
+   If a and b are kept secret, this method is considered very secure.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+curve25519_generator(Gs) :-
+        length(Gs0, 32),
+        Gs0 = [9|Zs],
+        maplist(=(0), Zs),
+        maplist(char_code, Gs, Gs0).
+
+curve25519_scalar_mult(Scalar, Point, Result) :-
+        (   integer_si(Scalar) ->
+            Scalar #>= 0,
+            Scalar #< 2^256,
+            length(ScalarBytes, 32),
+            bytes_integer(ScalarBytes, Scalar)
+        ;   ScalarBytes = Scalar,
+            must_be_bytes(ScalarBytes, curve25519_scalar_mult/3),
+            length(ScalarBytes, 32)
+        ),
+        maplist(char_code, Point, PointBytes),
+        '$curve25519_scalar_mult'(ScalarBytes, PointBytes, Result).
+
+bytes_integer(Bs, N) :-
+        foldl(pow, Bs, 0-0, N-_).
+
+pow(B, N0-I0, N-I) :-
+        B in 0..255,
+        N #= N0 + B*256^I0,
+        I #= I0 + 1.
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Operations on Elliptic Curves
+   =============================
+
+   Sample use: Establishing a shared secret S, using ECDH key exchange.
+
+    ?- crypto_name_curve(secp256k1, C),
+       crypto_curve_generator(C, Generator),
+       PrivateKey = 10,
+       crypto_curve_scalar_mult(C, PrivateKey, Generator, PublicKey),
+       Random = 12,
+       crypto_curve_scalar_mult(C, Random, Generator, R),
+       crypto_curve_scalar_mult(C, Random, PublicKey, S),
+       crypto_curve_scalar_mult(C, PrivateKey, R, S).
+
+   For better security, new code should use Curve25519 instead.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   An elliptic curve over a prime field F_p is represented as:
+
+   curve(Name,P,A,B,point(X,Y),Order,FieldLength,Cofactor).
+
+   First, we define suitable accessors.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+curve_name(curve(Name,_,_,_,_,_,_,_), Name).
+curve_p(curve(_,P,_,_,_,_,_,_), P).
+curve_a(curve(_,_,A,_,_,_,_,_), A).
+curve_b(curve(_,_,_,B,_,_,_,_), B).
+curve_field_length(curve(_,_,_,_,_,_,FieldLength,_), FieldLength).
+
+crypto_curve_generator(curve(_,_,_,_,G,_,_,_), G).
+crypto_curve_order(curve(_,_,_,_,_,Order,_,_), Order).
+
+crypto_curve_scalar_mult(Curve, Scalar, point(X,Y), point(RX, RY)) :-
+        must_be(integer, Scalar),
+        must_be_on_curve(Curve, point(X,Y)),
+        curve_name(Curve, Name),
+        curve_field_length(Curve, L0),
+        L #= 2*L0, % for hex encoding
+        phrase(format_("04~|~`0t~16r~*+~`0t~16r~*+", [X,L,Y,L]), Hex),
+        hex_bytes(Hex, Bytes),
+        '$crypto_curve_scalar_mult'(Name, Scalar, Bytes, SX, SY),
+        number_chars(RX, SX),
+        number_chars(RY, SY).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+?- crypto_name_curve(secp256k1, Curve),
+   crypto_curve_generator(Curve, G),
+   crypto_curve_scalar_mult(Curve, 2, G, R).
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Validation.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+curve_contains_point(Curve, point(QX,QY)) :-
+        curve_a(Curve, A),
+        curve_b(Curve, B),
+        curve_p(Curve, P),
+        QY^2 mod P #= (QX^3 + A*QX + B) mod P.
+
+must_be_on_curve(Curve, P) :-
+        \+ curve_contains_point(Curve, P),
+        domain_error(point_on_curve, P, crypto_elliptic_curves).
+must_be_on_curve(Curve, P) :- curve_contains_point(Curve, P).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Predefined curves
+   =================
+
+   List available curves:
+
+   $ openssl ecparam -list_curves
+
+   Show curve parameters for secp256k1:
+
+   $ openssl ecparam -param_enc explicit -conv_form uncompressed \
+                     -text -no_seed -name secp256k1
+
+   You must remove the leading "04:" from the generator.
+
+   The field length depends on the order of the curve and can be computed
+   with order_field_length/2.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+order_field_length(Order, L) :-
+        fitting_exponent(Order, 0, E),
+        L #= (E + 7) // 8.
+
+fitting_exponent(N, E0, E) :-
+        (   2^E0 #>= N -> E #= E0
+        ;   E1 #= E0 + 1,
+            fitting_exponent(N, E1, E)
+        ).
+
+crypto_name_curve(secp112r1,
+                  curve(secp112r1,
+                        0x00db7c2abf62e35e668076bead208b,
+                        0x00db7c2abf62e35e668076bead2088,
+                        0x659ef8ba043916eede8911702b22,
+                        point(0x09487239995a5ee76b55f9c2f098,
+                              0xa89ce5af8724c0a23e0e0ff77500),
+                        0x00db7c2abf62e35e7628dfac6561c5,
+                        14,
+                        1)).
+crypto_name_curve(secp256k1,
+                  curve(secp256k1,
+                        0x00fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f,
+                        0x0,
+                        0x7,
+                        point(0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798,
+                              0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8),
+                        0x00fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141,
+                        32,
+                        1)).

src/lib/csv.pl

@@ -0,0 +1,238 @@
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Predicates for parsing CSV data
+
+
+  Read csv files
+
+  Only two options with default values :
+  - token_separator(',')
+  - with_header(true)
+
+  Examples
+
+  * parsing a csv string:
+
+  ?- use_module(library(csv)).
+  ?- use_module(library(dcgs)).
+  ?- phrase(parse_csv(Data), "col1,col2,col3,col4\none,2,,three").
+    Data = frame(["col1","col2","col3","col4"],[["one",2,[],"three"]]).
+
+  * with some options:
+
+  ?- phrase(parse_csv(Data, [with_header(false), token_separator(';')]), "one;2;;three").
+    Data = frame([],[["one",2,[],"three"]]).
+
+  * parsing a csv file:
+
+  ?- use_module(library(csv)).
+  ?- use_module(library(pio)).
+  ?- phrase_from_file(parse_csv(frame(Header, Rows)), './test.csv').
+
+
+  Write csv files
+
+  Four options with default values :
+  - line_separator('\n')
+  - token_separator(',')
+  - with_header(true)
+  - null_value(empty)
+
+  Examples
+
+  * writing a csv file:
+
+  ?- use_module(library(csv)).
+  ?- write_csv('./test.csv', frame(["col1","col2","col3","col4"], [["one",2,[],"three"]])).
+
+  * with some options
+
+  ?- use_module(library(csv)).
+  ?- write_csv('./test.csv', frame(["col1","col2","col3","col4"], [["one",2,[],"three"]]), [with_header(false), line_separator('\r\n'), token_separator(';'), null_value('\\N')]).
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+:- module(csv, [
+  parse_csv//1,
+  parse_csv//2,
+  write_csv/2,
+  write_csv/3
+]).
+
+:- use_module(library(format)).
+:- use_module(library(dcgs)).
+:- use_module(library(iso_ext)).
+:- use_module(library(lists)).
+
+
+option(W, O) :-
+  ( member(W, O) -> true
+  ; throw(error(domain_error(csv_option, W), option/2))).
+
+
+option_extends([], Opt, Opt).
+option_extends([X | Y], Opt0, Opt) :-
+  functor(X, Name, 1),
+  F0 =.. [Name, _],
+  ( select(F0, Opt0, R) ->
+    option_extends(Y, [X | R], Opt)
+  ; option_extends(Y, [X | Opt0], Opt) ).
+
+
+%% -- write --
+
+
+escaped_field([], []).
+escaped_field(['"' | Y], ['"', '"' | R]) :-
+  escaped_field(Y, R).
+escaped_field([X | Y], [X | R]) :-
+  X \== '"',
+  escaped_field(Y, R).
+
+
+ensure_escaped(Field, Field) :-
+  (atom(Field); integer(Field); float(Field)).
+ensure_escaped([X | Y], Field) :-
+  escaped_field([X | Y], Field).
+
+
+write_field(Out, Field, Opt) :-
+  ( Field \== [] ->
+    ensure_escaped(Field, Field0),
+    format(Out, "~w", [Field0])
+  ; option(null_value(Null_Value), Opt),
+    ( Null_Value == empty -> true
+    ; format(Out, "~w", [Null_Value]))).
+
+
+write_row(Out, [Field], Opt) :-
+  write_field(Out, Field, Opt).
+write_row(Out, [Field, X | Y], Opt) :-
+  write_field(Out, Field, Opt),
+  option(token_separator(Tk_Sep), Opt),
+  format(Out, "~w", [Tk_Sep]),
+  write_row(Out, [X | Y], Opt).
+
+
+write_rows(Out, [Row], Opt) :-
+  write_row(Out, Row, Opt).
+write_rows(Out, [Row, X | Y], Opt) :-
+  option(line_separator(Line_Sep), Opt),
+  write_row(Out, Row, Opt),
+  format(Out, "~w", [Line_Sep]),
+  write_rows(Out, [X | Y], Opt).
+
+
+write_csv_(Out, frame(Header, Rows), Opt) :-
+  option(with_header(With_Header), Opt),
+  ( With_Header == true -> 
+    write_row(Out, Header, Opt),
+    option(line_separator(Line_Sep), Opt),
+    format(Out, "~w", [Line_Sep])
+  ; true),
+  write_rows(Out, Rows, Opt).
+
+
+write_csv(File_Name, Frm, Opt) :-
+  option_extends(Opt, [
+    null_value(empty),
+    token_separator(','),
+    with_header(true),
+    line_separator('\n')
+  ], Opt0),
+  setup_call_cleanup(
+    open(File_Name, write, Out),
+    write_csv_(Out, Frm, Opt0),
+    close(Out)).
+write_csv(File_Name, Frm) :-
+  write_csv(File_Name, Frm, []).
+
+
+%% -- read --
+
+
+tokens([], Opt), [Tk_Sep] -->
+  { option(token_separator(Tk_Sep), Opt) },
+  [Tk_Sep],
+  !.
+tokens([], _), "\r\n" -->
+  "\r\n",
+  !.
+tokens([], _), "\n" -->
+  "\n",
+  !.
+tokens([], _), "\r" -->
+  "\r",
+  !.
+tokens([X | Y], Opt) -->
+  [X],
+  !,
+  tokens(Y, Opt).
+tokens([], _) --> [].
+
+
+field(R, Opt) -->
+  "\"",
+  !,
+  string_tokens(R, Opt).
+field(R, Opt) -->
+  tokens(R0, Opt),
+  { R0 \== [],
+    catch(number_chars(R, R0), _, R = R0)
+  }.
+field([], _) --> [].
+
+
+string_tokens(R, Opt) -->
+  [X],
+  ( { X == '"' } ->
+    ( "\"" ->
+      { R = [X | Y] },
+      string_tokens(Y, Opt)
+    ; { R = [] })
+  ; { R = [X | Y] },
+    string_tokens(Y, Opt)).
+
+
+end_token --> "\r\n".
+end_token --> "\n".
+end_token --> "\r".
+end_token --> [].
+
+
+separator(Opt) -->
+    { option(token_separator(Tk_Sep), Opt) },
+    [Tk_Sep].
+
+
+row([X | Y], Opt) -->
+  field(X, Opt),
+  !,
+  ( separator(Opt) ->
+    row(Y, Opt)
+  ; end_token ->
+    { Y = [] }).
+
+
+rows(R, Opt) -->
+  row(X, Opt),
+  !,
+  ( { X \== [[]] } ->
+    rows(Y, Opt),
+    { R = [X | Y] }
+  ; { R = [] }).
+
+
+parse_csv(frame(Header, Rows), Opt) --> 
+  { option_extends(Opt, [
+      with_header(true),
+      token_separator(',')
+    ], Opt0)
+  },
+  ( { option(with_header(With_Header), Opt0),
+      With_Header == true } ->
+    row(Header, Opt0),
+    { Header \== [[]] },
+    end_token
+  ; { Header = [] }),
+  rows(Rows, Opt0).
+parse_csv(R) -->
+  parse_csv(R, []).

src/lib/dcgs.pl

@@ -1,16 +1,11 @@
-:- module(dcgs, [op(1200, xfx, -->),
-		 op(1105, xfy, '|'),
-		 phrase/2,
-		 phrase/3]).
+:- module(dcgs,
+          [op(1105, xfy, '|'),
+		   phrase/2,
+		   phrase/3]).
 
 :- use_module(library(error)).
 :- use_module(library(lists), [append/3]).
 
-user:term_expansion(Term0, Term) :-
-    nonvar(Term0),
-    dcg_rule(Term0, (Head :- Body)),
-    Term = (Head :- Body).
-
 phrase(GRBody, S0) :-
     phrase(GRBody, S0, []).
 
@@ -133,3 +128,8 @@ dcg_cbody(\+ GRBody, S0, S, ( \+ phrase(GRBody,S0,_), S0 = S )).
 dcg_cbody(( GRIf -> GRThen ), S0, S, ( If -> Then )) :-
     dcg_body(GRIf, S0, S1, If),
     dcg_body(GRThen, S1, S, Then).
+
+user:term_expansion(Term0, Term) :-
+    nonvar(Term0),
+    dcg_rule(Term0, (Head :- Body)),
+    Term = (Head :- Body).

src/lib/debug.pl

@@ -0,0 +1,22 @@
+% Source: https://stackoverflow.com/a/30791637
+
+:- module(debug, [
+    op(900, fx, $),
+    op(900, fx, $-),
+    op(950, fy, *),
+    (*)/1,
+    ($)/1,
+    ($-)/1
+]).
+
+:- use_module(library(format), [portray_clause/1]).
+
+$-(G_0) :-
+   catch(G_0, Ex, ( portray_clause(exception:Ex:G_0), throw(Ex) ) ).
+
+$(G_0) :-
+   portray_clause(call:G_0),
+   $-G_0,
+   portray_clause(exit:G_0).
+
+*(_).

src/lib/error.pl

@@ -1,5 +1,9 @@
 :- module(error, [must_be/2,
-                  can_be/2]).
+                  can_be/2,
+                  instantiation_error/1,
+                  domain_error/3,
+                  type_error/3
+                  ]).
 
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    Written September 2018 by Markus Triska (triska@metalevel.at)
@@ -23,7 +27,8 @@
 
        - integer
        - atom
-       - list.
+       - list
+       - boolean
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 must_be(Type, Term) :-
@@ -32,31 +37,41 @@ must_be(Type, Term) :-
 
 must_be_(Type, _) :-
         var(Type),
-        instantiation_error(Type).
+        instantiation_error(must_be/2).
 must_be_(var, Term) :-
         (   var(Term) -> true
-        ;   throw(error(uninstantiation_error, _))
+        ;   throw(error(uninstantiation_error, must_be/2))
         ).
 must_be_(integer, Term) :- check_(integer, integer, Term).
 must_be_(atom, Term)    :- check_(atom, atom, Term).
+must_be_(character, T)  :- check_(character, character, T).
 must_be_(list, Term)    :- check_(ilist, list, Term).
 must_be_(type, Term)    :- check_(type, type, Term).
+must_be_(boolean, Term) :- check_(boolean, boolean, Term).
 
 check_(Pred, Type, Term) :-
-        (   var(Term) -> instantiation_error(Term)
+        (   var(Term) -> instantiation_error(must_be/2)
         ;   call(Pred, Term) -> true
-        ;   type_error(Type, Term)
+        ;   type_error(Type, Term, must_be/2)
         ).
 
-ilist(V) :- var(V), instantiation_error(V).
+boolean(B) :- ( B == true ; B == false ).
+
+character(C) :-
+        atom(C),
+        atom_length(C, 1).
+
+ilist(V) :- var(V), instantiation_error(must_be/2).
 ilist([]).
 ilist([_|Ls]) :- ilist(Ls).
 
 type(type).
 type(integer).
 type(atom).
+type(character).
 type(list).
 type(var).
+type(boolean).
 
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    can_be(Type, Term)
@@ -76,12 +91,14 @@ can_be(Type, Term) :-
         must_be(type, Type),
         (   var(Term) -> true
         ;   can_(Type, Term) -> true
-        ;   type_error(Type, Term)
+        ;   type_error(Type, Term, can_be/2)
         ).
 
 can_(integer, Term) :- integer(Term).
 can_(atom, Term)    :- atom(Term).
+can_(character, T)  :- character(T).
 can_(list, Term)    :- list_or_partial_list(Term).
+can_(boolean, Term) :- boolean(Term).
 
 list_or_partial_list(Var) :- var(Var).
 list_or_partial_list([]).
@@ -92,11 +109,11 @@ list_or_partial_list([_|Ls]) :-
    Shorthands for throwing ISO errors.
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
-instantiation_error(_Term) :-
-    throw(error(instantiation_error, _)).
+instantiation_error(Context) :-
+    throw(error(instantiation_error, Context)).
 
-domain_error(Type, Term) :-
-    throw(error(domain_error(Type, Term), _)).
+domain_error(Type, Term, Context) :-
+    throw(error(domain_error(Type, Term), Context)).
 
-type_error(Type, Term) :-
-    throw(error(type_error(Type, Term), _)).
+type_error(Type, Term, Context) :-
+    throw(error(type_error(Type, Term), Context)).

src/lib/files.pl

@@ -0,0 +1,200 @@
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Written June 2020 by Markus Triska (triska@metalevel.at)
+   Part of Scryer Prolog.
+
+   Predicates for reasoning about files and directories.
+
+   In this library, directories and files are represented as
+   *lists of characters*. This is an ideal representation:
+
+   -) Lists of characters can be conveniently reasoned about with DCGs
+      and built-in Prolog predicates from library(lists). This alone
+      is already a very compelling argument to use them.
+   -) Other Scryer libraries such as library(http/http_open) also already
+      use lists of characters to represent paths.
+   -) File names are mostly ephemeral, so it is good for efficiency
+      that they can quickly allocated transiently on the heap, leaving the
+      atom table mostly unaffected. Indexing is almost never needed
+      for file names. If needed, it should be added to the engine.
+   -) The previous point is also good for security, since the system
+      leaves little trace of which files were even accessed.
+   -) Scryer Prolog represents lists of characters extremely compactly.
+
+   Some Prolog programmers will likely find this representation quite
+   unusual, because files are represented as *atoms* in many systems.
+
+   However, the ISO standard only demands that sources and sinks be
+   *ground* terms, so lists of characters are completely admissible:
+
+       A source/sink is specified as an implementation defined
+       ground term in a call of open/4 (8.11.5). All subsequent
+       references to the source/sink are made by referring to a
+       stream-term (7.10.2) or alias (7.10.2.2).
+
+   I believe that with the advent of Scryer Prolog and its efficient
+   representation of strings as lists of characters, we should take
+   this opportunity for improvement, and in fact extend the use of
+   lists of characters also to other predicates like open/3.
+
+   Please note that we *cannot* simply accept *both* representations,
+   because that would invalidate the type errors raised by this library,
+   and make future extensions for type checking impossible.
+
+   So I ask you: Please try out this representation for a few months.
+   It simplifies working with files considerably. Once we have collected
+   more experience with this representations, please let us consider
+   how to proceed in such a way that we can call it an improvement.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+:- module(files, [directory_files/2,
+                  file_size/2,
+                  file_exists/1,
+                  directory_exists/1,
+                  delete_file/1,
+                  make_directory/1,
+                  working_directory/2,
+                  path_canonical/2,
+                  path_segments/2,
+                  file_modification_time/2,
+                  file_creation_time/2,
+                  file_access_time/2]).
+
+:- use_module(library(error)).
+:- use_module(library(lists)).
+:- use_module(library(charsio)).
+
+list_of_chars(Cs) :-
+        must_be(list, Cs),
+        maplist(must_be(character), Cs).
+
+directory_files(Directory, Files) :-
+        list_of_chars(Directory),
+        can_be(list, Files),
+        '$directory_files'(Directory, Files).
+
+file_size(File, Size) :-
+        list_of_chars(File),
+        can_be(integer, Size),
+        '$file_size'(File, Size).
+
+file_exists(File) :-
+        list_of_chars(File),
+        '$file_exists'(File).
+
+directory_exists(Directory) :-
+        list_of_chars(Directory),
+        '$directory_exists'(Directory).
+
+make_directory(Directory) :-
+        list_of_chars(Directory),
+        '$make_directory'(Directory).
+
+delete_file(File) :-
+        list_of_chars(File),
+        '$delete_file'(File).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Dir0 is the current working directory, and the working directory
+   is changed to Dir.
+
+   Use working_directory(Ds, Ds) to determine the current working directory,
+   and leave it as is.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+working_directory(Dir0, Dir) :-
+        can_be(list, Dir0),
+        can_be(list, Dir),
+        '$working_directory'(Dir0, Dir).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   True iff Cs is the canonical, absolute path of Ps.
+
+   All intermediate components are normalized, and all symbolic links
+   are resolved.
+
+   The predicate fails in the following situations, though not
+   necessarily *only* in these cases:
+
+      1. Ps is a path that does not exist.
+      2. A non-final component in Ps is not a directory.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+path_canonical(Ps, Cs) :-
+        must_be(list, Ps),
+        maplist(must_be(character), Ps),
+        can_be(list, Cs),
+        '$path_canonical'(Ps, Cs).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   T is, respectively, the modification, access or creation time of File.
+   T is a time stamp, suitable for use in format_time//2 in library(time).
+
+   For two time stamps A and B, if A precedes B, then A @< B holds.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+file_modification_time(File, T) :-
+        file_time_(File, modification, T).
+
+file_access_time(File, T) :-
+        file_time_(File, access, T).
+
+file_creation_time(File, T) :-
+        file_time_(File, creation, T).
+
+file_time_(File, Which, T) :-
+        '$file_time'(File, Which, T0),
+        read_term_from_chars(T0, T).
+
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   path_segments(Ps, Segments): True iff Segments are the segments of Ps.
+
+   Segments is the list of components of the path Ps that are
+   separated by the platform-specific directory separator. Each
+   segment is a list of characters.
+
+   At least one of the arguments must be instantiated.
+
+   Examples:
+
+      ?- path_segments("/hello/there", Segments).
+         Segments = [[],"hello","there"]
+      ;  false.
+
+      ?- path_segments(Path, ["hello","there"]).
+         Path = "hello/there"
+      ;  false.
+
+
+   To obtain the platform-specific directory separator, you can use:
+
+      ?- path_segments(Separator, ["",""]).
+         Separator = "/"
+      ;  false.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+path_segments(Path, Segments) :-
+        '$directory_separator'(Sep),
+        (   var(Path) ->
+            must_be(list, Segments),
+            maplist(list_of_chars, Segments),
+            append_with_separator(Segments, Sep, Path)
+        ;   list_of_chars(Path),
+            path_to_segments(Path, Sep, Segments)
+        ).
+
+append_with_separator([], _, []).
+append_with_separator([Segment|Segments], Sep, Path) :-
+        append_with_separator_(Segments, Segment, Sep, Path).
+
+append_with_separator_([], Segment, _, Segment).
+append_with_separator_([Segment|Segments], Prev, Sep, Path) :-
+        append(Prev, [Sep|Rest], Path),
+        append_with_separator_(Segments, Segment, Sep, Rest).
+
+path_to_segments(Path, Sep, Segments) :-
+        (   append(Front, [Sep|Ps], Path) ->
+            Segments = [Front|Rest],
+            path_to_segments(Ps, Sep, Rest)
+        ;   Segments = [Path]
+        ).

src/lib/format.pl

@@ -3,7 +3,7 @@
    Part of Scryer Prolog.
 
    This library provides the nonterminal format_//2 to describe
-   formatted strings. format/2 is provided for impure output.
+   formatted strings. format/[2,3] are provided for impure output.
 
    Usage:
    ======
@@ -28,6 +28,11 @@
            if N is 0 or omitted, no decimal point is used.
      ~ND   like ~Nd, separating digits to the left of the decimal point
            in groups of three, using the character "," (comma)
+     ~Nr   where N is an integer between 2 and 36: format the
+           next argument, which must be an integer, in radix N.
+           The characters "a" to "z" are used for radices 10 to 36.
+     ~NR   like ~Nr, except that "A" to "Z" are used for radices > 9
+     ~|    place a tab stop at this position
      ~N|   where N is an integer: place a tab stop at text column N
      ~N+   where N is an integer: place a tab stop N characters
            after the previous tab stop (or start of line)
@@ -44,6 +49,10 @@
    The predicate format/2 is like format_//2, except that it outputs
    the text on the terminal instead of describing it declaratively.
 
+   format/3, used as format(Stream, FormatString, Arguments), outputs
+   the described string to the given Stream. If Stream is a binary
+   stream, then the code of each emitted character must be in 0..255.
+
    If at all possible, format_//2 should be used, to stress pure parts
    that enable easy testing etc. If necessary, you can emit the list Ls
    with maplist(write, Ls).
@@ -55,7 +64,7 @@
    Example:
 
    ?- phrase(format_("~s~n~`.t~w!~12|", ["hello",there]), Cs).
-   %@    Cs = [h,e,l,l,o,'\n','.','.','.','.','.','.',t,h,e,r,e,!]
+   %@    Cs = "hello\n......there!"
    %@ ;  false.
 
    I place this code in the public domain. Use it in any way you want.
@@ -63,13 +72,17 @@
 
 :- module(format, [format_//2,
                    format/2,
-                   portray_clause/1
+                   format/3,
+                   portray_clause/1,
+                   portray_clause/2,
+                   listing/1
                   ]).
 
 :- use_module(library(dcgs)).
 :- use_module(library(lists)).
 :- use_module(library(error)).
 :- use_module(library(charsio)).
+:- use_module(library(between)).
 
 format_(Fs, Args) -->
         { must_be(list, Fs),
@@ -146,7 +159,7 @@ element_gluevar(glue(_,V), N, N) --> [V].
 
 cells([], Args, Tab, Es) -->
         (   { Args == [] } -> cell(Tab, Tab, Es)
-        ;   { domain_error(no_remaining_arguments, Args) }
+        ;   { domain_error(empty_list, Args, format_//2) }
         ).
 cells([~,~|Fs], Args, Tab, Es) --> !,
         cells(Fs, Args, Tab, [chars("~")|Es]).
@@ -160,9 +173,11 @@ cells([~,a|Fs], [Arg|Args], Tab, Es) --> !,
         { atom_chars(Arg, Chars) },
         cells(Fs, Args, Tab, [chars(Chars)|Es]).
 cells([~|Fs0], Args0, Tab, Es) -->
-        { numeric_argument(Fs0, Num, [d|Fs], Args0, [Arg|Args]) },
+        { numeric_argument(Fs0, Num, [d|Fs], Args0, [Arg0|Args]) },
         !,
-        { number_chars(Arg, Cs0) },
+        { Arg is Arg0, % evaluate compound expression
+          must_be(integer, Arg),
+          number_chars(Arg, Cs0) },
         (   { Num =:= 0 } -> { Cs = Cs0 }
         ;   { length(Cs0, L),
               (   L =< Num ->
@@ -204,12 +219,12 @@ cells([~|Fs0], Args0, Tab, Es) -->
 cells([~,s|Fs], [Arg|Args], Tab, Es) --> !,
         cells(Fs, Args, Tab, [chars(Arg)|Es]).
 cells([~,f|Fs], [Arg|Args], Tab, Es) --> !,
-        { number_chars(Arg, Chars) },
+        { format_number_chars(Arg, Chars) },
         cells(Fs, Args, Tab, [chars(Chars)|Es]).
 cells([~|Fs0], Args0, Tab, Es) -->
         { numeric_argument(Fs0, Num, [f|Fs], Args0, [Arg|Args]) },
         !,
-        { number_chars(Arg, Cs0),
+        { format_number_chars(Arg, Cs0),
           phrase(upto_what(Bs, .), Cs0, Cs),
           (   Num =:= 0 -> Chars = Bs
           ;   (   Cs = ['.'|Rest] ->
@@ -234,6 +249,16 @@ cells([~|Fs0], Args0, Tab, Es) -->
               append(Bs, ['.'|Ds], Chars)
           ) },
         cells(Fs, Args, Tab, [chars(Chars)|Es]).
+cells([~|Fs0], Args0, Tab, Es) -->
+        { numeric_argument(Fs0, Num, [r|Fs], Args0, [Arg|Args]) },
+        !,
+        { integer_to_radix(Arg, Num, lowercase, Cs) },
+        cells(Fs, Args, Tab, [chars(Cs)|Es]).
+cells([~|Fs0], Args0, Tab, Es) -->
+        { numeric_argument(Fs0, Num, ['R'|Fs], Args0, [Arg|Args]) },
+        !,
+        { integer_to_radix(Arg, Num, uppercase, Cs) },
+        cells(Fs, Args, Tab, [chars(Cs)|Es]).
 cells([~,'`',Char,t|Fs], Args, Tab, Es) --> !,
         cells(Fs, Args, Tab, [glue(Char,_)|Es]).
 cells([~,t|Fs], Args, Tab, Es) --> !,
@@ -251,18 +276,18 @@ cells([~|Fs0], Args0, Tab0, Es) -->
         cells(Fs, Args, Tab, []).
 cells([~,C|_], _, _, _) -->
         { atom_chars(A, [~,C]),
-          domain_error(format_string, A) }.
+          domain_error(format_string, A, format_//2) }.
 cells(Fs0, Args, Tab, Es) -->
         { phrase(upto_what(Fs1, ~), Fs0, Fs),
           Fs1 = [_|_] },
         cells(Fs, Args, Tab, [chars(Fs1)|Es]).
 
-domain_error(Type, Term) :-
-        throw(error(domain_error(Type, Term), _)).
+format_number_chars(N0, Chars) :-
+        N is N0, % evaluate compound expression
+        number_chars(N, Chars).
 
 n_newlines(0) --> !.
-n_newlines(1) --> !, [newline].
-n_newlines(N0) --> { N0 > 1, N is N0 - 1 }, [newline], n_newlines(N).
+n_newlines(N0) --> { N0 > 0, N is N0 - 1 }, [newline], n_newlines(N).
 
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 ?- phrase(upto_what(Cs, ~), "abc~test", Rest).
@@ -309,13 +334,51 @@ pow10(D, N0-Pow0, N-Pow) :-
         N is N0 + D*10^Pow0,
         Pow is Pow0 + 1.
 
+integer_to_radix(I0, R, Which, Cs) :-
+        I is I0, % evaluate compound expression
+        must_be(integer, I),
+        must_be(integer, R),
+        (   \+ between(2, 36, R) ->
+            domain_error(radix, R, format_//2)
+        ;   true
+        ),
+        digits(Which, Ds),
+        (   I < 0 ->
+            Pos is abs(I),
+            phrase(integer_to_radix_(Pos, R, Ds), Cs0, "-")
+        ;   I =:= 0 -> Cs0 = "0"
+        ;   phrase(integer_to_radix_(I, R, Ds), Cs0)
+        ),
+        reverse(Cs0, Cs).
+
+integer_to_radix_(0, _, _) --> !.
+integer_to_radix_(I0, R, Ds) -->
+        { M is I0 mod R,
+          nth0(M, Ds, D),
+          I is I0 // R
+          },
+        [D],
+        integer_to_radix_(I, R, Ds).
+
+digits(lowercase, "0123456789abcdefghijklmnopqrstuvwxyz").
+digits(uppercase, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ").
+
+
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    Impure I/O, implemented as a small wrapper over format_//2.
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 format(Fs, Args) :-
+        current_output(Stream),
+        format(Stream, Fs, Args).
+
+format(Stream, Fs, Args) :-
         phrase(format_(Fs, Args), Cs),
-        maplist(write, Cs).
+        % we use a specialised internal predicate that uses only a
+        % single "write" operation for efficiency. It is equivalent to
+        % maplist(put_char(Stream), Cs). It also works for binary streams.
+        '$put_chars'(Stream, Cs),
+        flush_output(Stream).
 
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 ?- phrase(cells("hello", [], 0, []), Cs).
@@ -340,11 +403,11 @@ Cs = [cell(0,4,[glue(' ',_38),chars([a]),glue(' ',_62)])].
 ?- phrase(format_("hello~n~tthere~6|", []), Ls).
 
 ?- format("~ta~t~4|", []).
-    a  true
+ a     true
 ;  false.
 
 ?- format("~ta~tb~tc~10|", []).
-     a  b   ctrue
+  a  b   c   true
 ;  false.
 
 ?- format("~tabc~3|", []).
@@ -352,90 +415,104 @@ Cs = [cell(0,4,[glue(' ',_38),chars([a]),glue(' ',_62)])].
 ?- format("~ta~t~4|", []).
 
 ?- format("~ta~t~tb~tc~20|", []).
-       a        b     ctrue
+    a        b     c   true
 ;  false.
 
 ?- format("~2f~n", [3]).
-   3.00
-true
+3.00
+   true
 
 ?- format("~20f", [0.1]).
-   0.10000000000000000000true % this should use higher accuracy!
+0.10000000000000000000   true % this should use higher accuracy!
 ;  false.
 
 ?- X is atan(2), format("~7f~n", [X]).
-   1.1071487
-X = 1.1071487177940906
+1.1071487
+   X = 1.1071487177940906
 
 ?- format("~`at~50|~n", []).
-   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-true
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+   true
 
 ?- format("~t~N", []).
 
 ?- format("~q", [.]).
-   '.'true
+'.'   true
+
+?- format("~12r", [300]).
+210   true
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-   We also provide a rudimentary version of portray_clause/1.
+   We also provide rudimentary versions of portray_clause/1 and listing/1.
 
-   In the eventual library organization, portray_clause/1
-   and related predicates (such as listing/1) may be placed
-   in their own dedicated library.
+   In the eventual library organization, portray_clause/1 and
+   related predicates may be placed in their own dedicated library.
 
    portray_clause/1 is useful for printing solutions in such a way
    that they can be read back with read/1.
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 portray_clause(Term) :-
+        current_output(Out),
+        portray_clause(Out, Term).
+
+portray_clause(Stream, Term) :-
         phrase(portray_clause_(Term), Ls),
-        maplist(write, Ls).
+        format(Stream, "~s", [Ls]).
 
 portray_clause_(Term) -->
-        portray_(Term), ".\n".
+        { term_variables(Term, Vs),
+          foldl(var_name, Vs, VNs, 0, _) },
+        portray_(Term, VNs), ".\n".
 
-literal(Lit) --> format_("~q", [Lit]).
+var_name(V, Name=V, Num0, Num) :-
+        charsio:fabricate_var_name(numbervars, Name, Num0),
+        Num is Num0 + 1.
 
-portray_(Var) --> { var(Var) }, !, literal(Var).
-portray_((Head :- Body)) --> !,
-        literal(Head), " :-\n",
-        body_(Body, 0, 8).
-portray_((Head --> Body)) --> !,
-        literal(Head), " -->\n",
-        body_(Body, 0, 8).
-portray_(Any) --> literal(Any).
+literal(Lit, VNs) -->
+        { write_term_to_chars(Lit, [quoted(true),variable_names(VNs)], Ls) },
+        list(Ls).
+
+portray_(Var, VNs) --> { var(Var) }, !, literal(Var, VNs).
+portray_((Head :- Body), VNs) --> !,
+        literal(Head, VNs), " :-\n",
+        body_(Body, 0, 3, VNs).
+portray_((Head --> Body), VNs) --> !,
+        literal(Head, VNs), " -->\n",
+        body_(Body, 0, 3, VNs).
+portray_(Any, VNs) --> literal(Any, VNs).
 
 
-body_(Var, C, I) --> { var(Var) }, !,
+body_(Var, C, I, VNs) --> { var(Var) }, !,
         indent_to(C, I),
-        literal(Var).
-body_((A,B), C, I) --> !,
-        body_(A, C, I), ",\n",
-        body_(B, 0, I).
-body_((A ; Else), C, I) --> % ( If -> Then ; Else )
+        literal(Var, VNs).
+body_((A,B), C, I, VNs) --> !,
+        body_(A, C, I, VNs), ",\n",
+        body_(B, 0, I, VNs).
+body_((A ; Else), C, I, VNs) --> % ( If -> Then ; Else )
         { nonvar(A), A = (If -> Then) },
         !,
         indent_to(C, I),
         "(  ",
         { C1 is I + 3 },
-        body_(If, C1, C1), " ->\n",
-        body_(Then, 0, C1), "\n",
-        else_branch(Else, C1, I).
-body_((A;B), C, I) --> !,
+        body_(If, C1, C1, VNs), " ->\n",
+        body_(Then, 0, C1, VNs), "\n",
+        else_branch(Else, C1, I, VNs).
+body_((A;B), C, I, VNs) --> !,
         indent_to(C, I),
         "(  ",
         { C1 is I + 3 },
-        body_(A, C1, C1), "\n",
-        else_branch(B, C1, I).
-body_(Goal, C, I) -->
-        indent_to(C, I), literal(Goal).
+        body_(A, C1, C1, VNs), "\n",
+        else_branch(B, C1, I, VNs).
+body_(Goal, C, I, VNs) -->
+        indent_to(C, I), literal(Goal, VNs).
 
 
-else_branch(Else, C, I) -->
+else_branch(Else, C, I, VNs) -->
         indent_to(0, I),
-        ";", "  ", % (see #336)
-        body_(Else, C, C), "\n",
+        ";  ",
+        body_(Else, C, C, VNs), "\n",
         indent_to(0, I),
         ")".
 
@@ -444,38 +521,60 @@ indent_to(CurrentColumn, Indent) -->
         format_("~t~*|", [Delta]).
 
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-?- portray_clause(a), nl.
-   a.
+?- portray_clause(a).
+a.
 
-?- nl, portray_clause((a :- b)), nl.
+?- portray_clause((a :- b)).
 a :-
-        b.
+   b.
 
-?- nl, portray_clause((a :- b, c, d)), nl.
+?- portray_clause((a :- b, c, d)).
 a :-
-        b,
-        c,
-        d.
+   b,
+   c,
+   d.
+   true
 
 
-?- nl, portray_clause([a,b,c,d]), nl.
+?- portray_clause([a,b,c,d]).
 "abcd".
 
-?- nl, portray_clause(X).
-?- nl, portray_clause((f(X) :- X)).
+?- portray_clause(X).
+?- portray_clause((f(X) :- X)).
 
-?- nl, portray_clause((h :- ( a -> b; c))).
+?- portray_clause((h :- ( a -> b; c))).
 
-?- nl, portray_clause((h :- ( (a -> x ; y) -> b; c))).
+?- portray_clause((h :- ( (a -> x ; y) -> b; c))).
 
-?- nl, portray_clause((h(X) :- ( (a(X) ; y(A,B)) -> b; c))).
+?- portray_clause((h(X) :- ( (a(X) ; y(A,B)) -> b; c))).
 
-?- nl, portray_clause((h :- (a,d;b,c) ; (b,e;d))).
+?- portray_clause((h :- (a,d;b,c) ; (b,e;d))).
 
-?- nl, portray_clause((a :- b ; c ; d)).
+?- portray_clause((a :- b ; c ; d)).
 
-?- nl, portray_clause((h :- L = '.')).
+?- portray_clause((h :- L = '.')).
 
-?- nl, portray_clause(-->(a, (b, {t}, d))).
+?- portray_clause(-->(a, (b, {t}, d))).
+
+?- portray_clause((A :- B)).
 
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+listing(PI) :-
+        nonvar(PI),
+        (   PI = Name/Arity0 ->
+            Arity = Arity0
+        ;   PI = Name//Arity0 ->
+            Arity is Arity0 + 2
+        ;   type_error(predicate_indicator, PI, listing/1)
+        ),
+        functor(Head, Name, Arity),
+        \+ \+ clause(Head, _), % only true if there is at least one clause
+        (   clause(Head, Body),
+            (   Body == true ->
+                portray_clause(Head)
+            ;   portray_clause((Head :- Body))
+            ),
+            false
+        ;   true
+        ).

src/lib/http/http_open.pl

@@ -0,0 +1,84 @@
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Written June 2020 by Markus Triska (triska@metalevel.at)
+   Part of Scryer Prolog.
+
+   http_open(+Address, -Stream, +Options)
+   ======================================
+
+   Yields Stream to read the body of an HTTP reply from Address.
+   Address is a list of characters, and includes the method. Both HTTP
+   and HTTPS are supported. Redirects are followed.
+
+   Currently, Options must be the empty list. Options may be
+   added in the future to give more control over the connection.
+
+   We use HTTP/1.0 until we can read chunked transfer-encoding.
+
+   Example:
+
+       ?- http_open("https://github.com/mthom/scryer-prolog", S, []).
+       %@    S = '$stream'(0x7f86f94a6cd0)
+       %@ ;  false.
+
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+:- module(http_open, [http_open/3]).
+
+:- use_module(library(sockets)).
+:- use_module(library(error)).
+:- use_module(library(format)).
+:- use_module(library(charsio)).
+:- use_module(library(dcgs)).
+:- use_module(library(lists), [member/2]).
+
+http_open(Address, Stream, Options) :-
+        must_be(list, Options),
+        must_be(list, Address),
+        once(phrase((list(SchemeCs), "://", list(Rest)), Address)),
+        atom_chars(Scheme, SchemeCs),
+        chars_host_url(Rest, Host, URL),
+        connect(Scheme, Host, Stream0),
+        format(Stream0, "\
+GET ~s HTTP/1.0\r\n\
+Host: ~w\r\n\
+User-Agent: Scryer Prolog\r\n\
+Connection: close\r\n\r\n\
+", [URL,Host]),
+        read_line_to_chars(Stream0, StatusLine, []),
+        once(phrase(("HTTP/1.",(['0']|['1'])," ",[D1]), StatusLine, _)),
+        read_header_lines(Stream0, HeaderLines),
+        handle_response(D1, HeaderLines, Stream0, Stream).
+
+list([]) --> [].
+list([L|Ls]) --> [L], list(Ls).
+
+handle_response('2', _, Stream, Stream).              % ok
+handle_response('3', HeaderLines, Stream0, Stream) :- % redirect
+        close(Stream0),
+        once((member(Line, HeaderLines),
+              phrase(("Location: ",list(Location),"\r\n"), Line))),
+        http_open(Location, Stream, []).
+
+% Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
+
+read_header_lines(Stream, Hs) :-
+        read_line_to_chars(Stream, Cs, []),
+        (   Cs == "" -> Hs = []
+        ;   Cs == "\r\n" -> Hs = []
+        ;   Hs = [Cs|Rest],
+            read_header_lines(Stream, Rest)
+        ).
+
+chars_host_url(Cs, Host, [/|Us]) :-
+        (   phrase((list(Hs),"/",list(Us)), Cs) ->
+            true
+        ;   Hs = Cs,
+            Us = []
+        ),
+        atom_chars(Host, Hs).
+
+connect(https, Host, Stream) :-
+        socket_client_open(Host:443, Stream, [tls(true)]).
+connect(http, Host, Stream) :-
+        socket_client_open(Host:80, Stream, []).
+

src/lib/iso_ext.pl

@@ -4,10 +4,10 @@
 %% ?- use_module(library(iso_ext)).
 
 :- module(iso_ext, [bb_b_put/2, bb_get/2, bb_put/2, call_cleanup/2,
-		            call_with_inference_limit/3, forall/2, maybe/0,
-		            partial_string/1, partial_string/3,
-		            partial_string_tail/2, set_random/1,
-		            setup_call_cleanup/3, variant/2]).
+                    call_with_inference_limit/3, forall/2,
+                    partial_string/1, partial_string/3,
+                    partial_string_tail/2, setup_call_cleanup/3,
+                    variant/2]).
 
 forall(Generate, Test) :-
     \+ (Generate, \+ Test).
@@ -22,9 +22,9 @@ bb_put(Key, _) :- throw(error(type_error(atom, Key), bb_put/2)).
 bb_b_put(Key, NewValue) :-
     (  '$bb_get_with_offset'(Key, OldValue, OldOffset) ->
        call_cleanup((store_global_var_with_offset(Key, NewValue) ; false),
-		    reset_global_var_at_offset(Key, OldValue, OldOffset))
+                    reset_global_var_at_offset(Key, OldValue, OldOffset))
     ;  call_cleanup((store_global_var_with_offset(Key, NewValue) ; false),
-		    reset_global_var_at_key(Key))
+                    reset_global_var_at_key(Key))
     ).
 
 store_global_var_with_offset(Key, Value) :- '$store_global_var_with_offset'(Key, Value).
@@ -68,7 +68,8 @@ scc_helper(C, G, Bb) :-
     ; '$reset_block'(NBb),
       '$fail').
 scc_helper(_, _, Bb) :-
-    '$reset_block'(Bb), '$get_ball'(Ball),
+    '$reset_block'(Bb),
+    '$get_ball'(Ball),
     '$call_with_default_policy'(run_cleaners_with_handling),
     '$erase_ball',
     '$call_with_default_policy'(throw(Ball)).
@@ -143,27 +144,12 @@ call_with_inference_limit(_, _, R, Bb, B) :-
 
 variant(X, Y) :- '$variant'(X, Y).
 
-% succeeds with probability 0.5.
-maybe :- '$maybe'.
-
-set_random(Seed) :-
-    (  nonvar(Seed) ->
-       (  Seed = seed(S) ->
-	  (  var(S) -> throw(error(instantiation_error, set_random/1))
-	  ;  integer(S) -> '$set_seed'(S)
-	  ;  throw(error(type_error(integer(S), set_random/1)))
-	  )
-       )
-    ;  throw(error(instantiation_error, set_random/1))
-    ).
-
-
 partial_string(String, L, L0) :-
     (  String == [] ->
        L = L0
     ;  catch(atom_chars(Atom, String),
-	     error(E, _),
-	     throw(error(E, partial_string/3))),
+         error(E, _),
+         throw(error(E, partial_string/3))),
        '$create_partial_string'(Atom, L, L0)
     ).
 

src/lib/lists.pl

@@ -1,8 +1,8 @@
 :- module(lists, [member/2, select/3, append/2, append/3, foldl/4, foldl/5,
 		  memberchk/2, reverse/2, length/2, maplist/2,
 		  maplist/3, maplist/4, maplist/5, maplist/6,
-		  maplist/7, maplist/8, maplist/9, same_length/2,
-		  sum_list/2, transpose/2]).
+		  maplist/7, maplist/8, maplist/9, same_length/2, nth0/3,
+		  sum_list/2, transpose/2, list_to_set/2]).
 
 
 :- use_module(library(error)).
@@ -21,9 +21,9 @@ length(Xs, N) :-
     ;  var(Xs0)  -> R is N-M, length_rundown(Xs0, R)).
 length(_, N) :-
     integer(N), !,
-    throw(error(domain_error(not_less_than_zero, N), length/2)).
+    domain_error(not_less_than_zero, N, length/2).
 length(_, N) :-
-    throw(error(type_error(integer, N), length/2)).
+    type_error(integer, N, length/2).
 
 length_addendum([], N, N).
 length_addendum([_|Xs], N, M) :-
@@ -63,7 +63,7 @@ reverse(Xs, Ys) :-
     ).
 
 reverse([], [], YsRev, YsRev).
-reverse([X1|Xs], [Y1|Ys], YsPreludeRev, Xss) :-
+reverse([_|Xs], [Y1|Ys], YsPreludeRev, Xss) :-
     reverse(Xs, Ys, [Y1|YsPreludeRev], Xss).
 
 
@@ -104,7 +104,7 @@ maplist(Cont, [E1|E1s], [E2|E2s], [E3|E3s], [E4|E4s], [E5|E5s], [E6|E6s], [E7|E7
 
 maplist(_, [], [], [], [], [], [], [], []).
 maplist(Cont, [E1|E1s], [E2|E2s], [E3|E3s], [E4|E4s], [E5|E5s], [E6|E6s], [E7|E7s], [E8|E8s]) :-
-    call(Cont, E1, E2, E3, E4, E5, E6, E7),
+    call(Cont, E1, E2, E3, E4, E5, E6, E7, E8),
     maplist(Cont, E1s, E2s, E3s, E4s, E5s, E6s, E7s, E8s).
 
 
@@ -149,3 +149,54 @@ transpose_(_, Fs, Lists0, Lists) :-
         maplist(list_first_rest, Lists0, Fs, Lists).
 
 list_first_rest([L|Ls], L, Ls).
+
+
+list_to_set(Ls0, Ls) :-
+        maplist(with_var, Ls0, LVs0),
+        keysort(LVs0, LVs),
+        same_elements(LVs),
+        pick_firsts(LVs0, Ls).
+
+pick_firsts([], []).
+pick_firsts([E-V|EVs], Fs0) :-
+        (   V == visited ->
+            Fs0 = Fs
+        ;   V = visited,
+            Fs0 = [E|Fs]
+        ),
+        pick_firsts(EVs, Fs).
+
+with_var(E, E-_).
+
+same_elements([]).
+same_elements([EV|EVs]) :-
+        foldl(unify_same, EVs, EV, _).
+
+unify_same(E-V, Prev-Var, E-V) :-
+        (   Prev == E ->
+            Var = V
+        ;   true
+        ).
+
+
+nth0(N, Es, E) :-
+        can_be(integer, N),
+        can_be(list, Es),
+        (   integer(N) ->
+            nth0_index(N, Es, E)
+        ;   nth0_search(N, Es, E)
+        ).
+
+nth0_index(0, [E|_], E) :- !.
+nth0_index(N, [_|Es], E) :-
+        N > 0,
+        N1 is N - 1,
+        nth0_index(N1, Es, E).
+
+nth0_search(N, Es, E) :-
+        nth0_search(0, N, Es, E).
+
+nth0_search(N, N, [E|_], E).
+nth0_search(N0, N, [_|Es], E) :-
+        N1 is N0 + 1,
+        nth0_search(N1, N, Es, E).

src/lib/os.pl

@@ -0,0 +1,58 @@
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Predicates for reasoning about the operating system (OS) environment.
+   Written July 2020 by Markus Triska (triska@metalevel.at).
+
+   Lists of characters are used throughout to represent keys and values.
+
+   Example:
+
+       ?- getenv("LANG", Ls).
+          Ls = "en_US.UTF-8"
+       ;  false.
+
+   Public domain code.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+:- module(os, [getenv/2,
+               setenv/2,
+               unsetenv/1]).
+
+:- use_module(library(error)).
+:- use_module(library(charsio)).
+:- use_module(library(lists)).
+
+getenv(Key, Value) :-
+        must_be_env_var(Key),
+        '$getenv'(Key, Value).
+
+setenv(Key, Value) :-
+        must_be_env_var(Key),
+        must_be_chars(Value),
+        '$setenv'(Key, Value).
+
+unsetenv(Key) :-
+        must_be_env_var(Key),
+        '$unsetenv'(Key).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   For now, we only support a restricted subset of variable names.
+
+   The reason is that Rust may panic if a key is empty, contains an
+   ASCII equals sign '=' or the NUL character '\0', or when the value
+   contains the NUL character.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+must_be_env_var(Cs) :-
+        must_be_chars(Cs),
+        Cs = [_|_],
+        (   maplist(permitted, Cs) -> true
+        ;   domain_error(env_var, Cs, os)
+        ).
+
+permitted(C) :- char_type(C, alnum).
+permitted(C) :- char_type(C, ascii_punctuation).
+permitted('_').
+
+must_be_chars(Cs) :-
+        must_be(list, Cs),
+        maplist(must_be(character), Cs).

src/lib/pairs.pl

@@ -1,6 +1,7 @@
 :- module(pairs, [pairs_keys_values/3,
 		  pairs_keys/2,
 		  pairs_values/2,
+		  group_pairs_by_key/2,
 		  map_list_to_pairs/3]).
 
 
@@ -19,3 +20,14 @@ map_list_to_pairs2([], _, []).
 map_list_to_pairs2([H|T0], Pred, [K-H|T]) :-
         call(Pred, H, K),
         map_list_to_pairs2(T0, Pred, T).
+
+
+group_pairs_by_key([], []).
+group_pairs_by_key([K-V|KVs0], [K-[V|Vs]|KVs]) :-
+        same_key(K, KVs0, Vs, KVs1),
+        group_pairs_by_key(KVs1, KVs).
+
+same_key(K0, [K1-V|KVs0], [V|Vs], KVs) :-
+        K0 == K1, !,
+        same_key(K0, KVs0, Vs, KVs).
+same_key(_, KVs, [], KVs).

src/lib/pio.pl

@@ -0,0 +1,42 @@
+:- module(pio, [phrase_from_file/2,
+                phrase_from_file/3]).
+
+:- use_module(library(dcgs)).
+:- use_module(library(error)).
+:- use_module(library(freeze)).
+:- use_module(library(iso_ext), [setup_call_cleanup/3, partial_string/3]).
+:- use_module(library(lists), [member/2]).
+
+phrase_from_file(NT, File) :-
+    phrase_from_file(NT, File, []).
+
+phrase_from_file(NT, File, Options) :-
+    (   var(File) -> instantiation_error(phrase_from_file/3)
+    ;   (\+ atom(File) ; File = []) ->
+            domain_error(source_sink, File, phrase_from_file/3)
+    ;   must_be(list, Options),
+        (   member(Var, Options), var(Var) -> instantiation_error(phrase_from_file/3)
+        ;   member(type(Type), Options) ->
+            must_be(atom, Type),
+            member(Type, [text,binary])
+        ;   Type = text
+        ),
+        setup_call_cleanup(open(File, read, Stream, [reposition(true)|Options]),
+                           (   stream_to_lazy_list(Stream, Xs),
+                               phrase(NT, Xs) ),
+                           close(Stream))
+   ).
+
+
+stream_to_lazy_list(Stream, Xs) :-
+        stream_property(Stream, position(Pos)),
+        freeze(Xs, reader_step(Stream, Pos, Xs)).
+
+reader_step(Stream, Pos, Xs0) :-
+        set_stream_position(Stream, Pos),
+        (   at_end_of_stream(Stream)
+        ->  Xs0 = []
+        ;   '$get_n_chars'(Stream, 4096, Cs),
+            partial_string(Cs, Xs0, Xs),
+            stream_to_lazy_list(Stream, Xs)
+        ).

src/lib/random.pl

@@ -0,0 +1,59 @@
+:- module(random, [maybe/0, random/1, random_integer/3, set_random/1]).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   To retain desirable declarative properties, predicates that internally
+   use random numbers should be equipped with an argument that specifies
+   the random seed. This makes everything completely reproducible.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+:- use_module(library(error)).
+
+% succeeds with probability 0.5.
+maybe :- '$maybe'.
+
+% The higher the precision, the slower it gets.
+random_number_precision(64).
+
+random(R) :-
+    var(R),
+    random_number_precision(N),
+    rnd(N, R).
+
+random_integer(Lower, Upper, R) :-
+    var(R),
+    (   (var(Lower) ; var(Upper)) ->
+            instantiation_error(random_integer/3)
+    ;   \+ integer(Lower) ->
+            domain_error(integer, Lower, random_integer/3)
+    ;   \+ integer(Upper) ->
+            domain_error(integer, Upper, random_integer/3)
+    ;   Upper > Lower,
+        random(R0),
+        R is floor((Upper - Lower) * R0 + Lower)
+    ).
+
+rnd(N, R) :-
+    rnd_(N, 0, R).
+
+rnd_(0, R, R) :- !.
+rnd_(N, R0, R) :-
+    maybe,
+    !,
+    N1 is N - 1,
+    rnd_(N1, R0, R).
+rnd_(N, R0, R) :-
+    N1 is N - 1,
+    R1 is R0 + 1.0 / 2.0 ^ N,
+    rnd_(N1, R1, R).
+
+set_random(Seed) :-
+    (   nonvar(Seed) ->
+        (  Seed = seed(S) ->
+        (  var(S) -> instantiation_error(set_random/1)
+        ;  integer(S) -> '$set_seed'(S)
+        ;  type_error(integer, S, set_random/1)
+        )
+        )
+    ;   instantiation_error(set_random/1)
+    ).
+

src/lib/sgml.pl

@@ -0,0 +1,92 @@
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Predicates for parsing HTML and XML documents.
+   Written June 2020 by Markus Triska (triska@metalevel.at)
+   Part of Scryer Prolog.
+
+   Currently, two predicates are provided:
+
+   -  load_html(+Source, -Es, +Options)
+   -  load_xml(+Source, -Es, +Options)
+
+   These predicates parse HTML and XML documents, respectively.
+
+   Source must be a stream, specified as stream(S), or a file,
+   specified as file(Name), where Name is a list of characters, or a
+   list of characters with the document contents.
+
+   Es is unified with the abstract syntax tree of the parsed document,
+   represented as a list of elements where each is of the form:
+
+   * a list of characters, representing text
+   * element(Name, Attrs, Children)
+     - Name is the name of the tag
+     - Attrs is a list of Key=Value pairs:
+       Key is an atom, and Value is a list of characters
+     - Children is a list of elements as specified here.
+
+   Currently, Options are ignored. In the future, more options may be
+   provided to control parsing.
+
+   Example:
+
+      ?- load_html("<html><head><title>Hello!</title></head></html>", Es, []).
+
+   Yielding:
+
+         Es = [element(html,[],
+                [element(head,[],
+                  [element(title,[],
+                    ["Hello!"])]),
+                 element(body,[],[])])].
+
+   library(xpath) provides convenient reasoning about parsed documents.
+   For example, to fetch the title of the document above, we can use:
+
+      ?- load_html("<html><head><title>Hello!</title></head></html>", Es, []),
+         xpath(Es, //title(text), T).
+
+   Yielding T = "Hello!".
+
+   Use http_open/3 from library(http/http_open) to read answers from
+   web servers via streams.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+:- module(sgml, [load_html/3,
+                 load_xml/3]).
+
+:- use_module(library(iso_ext)).
+:- use_module(library(error)).
+:- use_module(library(dcgs)).
+:- use_module(library(pio)).
+
+load_html(Source, Es, Options) :-
+        load_structure_(Source, Es, Options, html).
+load_xml(Source, Es, Options) :-
+        load_structure_(Source, Es, Options, xml).
+
+list([]) --> [].
+list([L|Ls]) --> [L], list(Ls).
+
+load_structure_([], [], _, _).
+load_structure_([C|Cs], [E], Options, What) :-
+        load_(What, [C|Cs], E, Options).
+load_structure_(file(Fs), [E], Options, What) :-
+        must_be(list, Options),
+        must_be(list, Fs),
+        atom_chars(File, Fs),
+        once(phrase_from_file(list(Cs), File)),
+        load_(What, Cs, E, Options).
+load_structure_(stream(Stream), [E], Options, What) :-
+        must_be(list, Options),
+        read_to_end(Stream, Cs),
+        load_(What, Cs, E, Options).
+
+load_(html, Cs, E, Options) :- '$load_html'(Cs, E, Options).
+load_(xml, Cs, E, Options) :- '$load_xml'(Cs, E, Options).
+
+read_to_end(Stream, Cs) :-
+        '$get_n_chars'(Stream, 4096, Cs0),
+        (   Cs0 = [] -> Cs = []
+        ;   partial_string(Cs0, Cs, Rest),
+            read_to_end(Stream, Rest)
+        ).

src/lib/sockets.pl

@@ -0,0 +1,67 @@
+
+:- module(sockets, [socket_client_open/3,
+                    socket_server_open/2,
+                    socket_server_accept/4,
+                    socket_server_close/1,
+                    current_hostname/1]).
+
+:- use_module(library(error)).
+:- use_module(library(lists)).
+
+parse_socket_options_(tls(TLS), tls-TLS) :-
+    must_be(boolean, TLS), !.
+parse_socket_options_(Option, OptionPair) :-
+    builtins:parse_stream_options_(Option, OptionPair).
+
+parse_socket_options(Options, OptionValues, Stub) :-
+    DefaultOptions = [alias-[], eof_action-eof_code, reposition-false, tls-false, type-text],
+    builtins:parse_options_list(Options, parse_socket_options_, DefaultOptions, OptionValues, Stub).
+
+socket_client_open(Addr, Stream, Options) :-
+    (  var(Addr) ->
+       throw(error(instantiation_error, socket_client_open/3))
+    ;
+       true
+    ),
+    must_be(var, Stream),
+    must_be(list, Options),
+    (  Addr = Address:Port,
+       atom(Address),
+       ( atom(Port) ; integer(Port) ) ->
+       true
+    ;
+       throw(error(type_error(socket_address, Addr), socket_client_open/3))
+    ),
+    parse_socket_options(Options,
+                         [Alias, EOFAction, Reposition, TLS, Type],
+                         socket_client_open/3),
+    '$socket_client_open'(Address, Port, Stream, Alias, EOFAction, Reposition, Type, TLS).
+
+
+socket_server_open(Addr, ServerSocket) :-
+    must_be(var, ServerSocket),
+    (  ( integer(Addr) ; var(Addr) ) ->
+       '$socket_server_open'([], Addr, ServerSocket)
+    ;
+       Addr = Address:Port,
+       must_be(atom, Address),
+       can_be(integer, Port),
+       '$socket_server_open'(Address, Port, ServerSocket)
+    ).
+
+
+socket_server_accept(ServerSocket, Client, Stream, Options) :-
+    must_be(var, Client),
+    must_be(var, Stream),
+    builtins:parse_stream_options(Options,
+                                  [Alias, EOFAction, Reposition, Type],
+                                  socket_server_accept/4),
+    '$socket_server_accept'(ServerSocket, Client, Stream, Alias, EOFAction, Reposition, Type).
+
+
+socket_server_close(ServerSocket) :-
+    '$socket_server_close'(ServerSocket).
+
+
+current_hostname(HostName) :-
+    '$current_hostname'(HostName).

src/lib/tabling.pl

@@ -8,12 +8,12 @@
 	    op(1150, fx, table)
 	  ]).
 
-:- use_module('tabling/double_linked_list').
-:- use_module('tabling/table_data_structure').
-:- use_module('tabling/batched_worklist').
-:- use_module('tabling/wrapper').
-:- use_module('tabling/global_worklist').
-:- use_module('tabling/table_link_manager').
+:- use_module(library(tabling/double_linked_list)).
+:- use_module(library(tabling/table_data_structure)).
+:- use_module(library(tabling/batched_worklist)).
+:- use_module(library(tabling/wrapper)).
+:- use_module(library(tabling/global_worklist)).
+:- use_module(library(tabling/table_link_manager)).
 
 :- use_module(library(cont)).
 :- use_module(library(lists)).
@@ -136,18 +136,14 @@ activate(Wrapper,Worker,T) :-
 delim(Wrapper,Worker,Table) :-
 %   debug(tabling, 'ACT: ~p on ~p', [Wrapper, Table]),
     reset(Worker,SourceCall,Continuation),
-   ( Continuation == none, var(SourceCall) ->
+   ( Continuation = none ->
      (	 add_answer(Table,Wrapper)
      ->	 true %debug(tabling, 'ADD: ~p', [Wrapper])
      ;	 %debug(tabling, 'DUP: ~p', [Wrapper]),
 	 fail
      )
    ;
-     (   Continuation = cont(Cont) ->
-	     true
-     ;   Continuation = none ->
-	     Cont = true
-     ),
+     Continuation = cont(Cont),
      SourceCall = call_info(_,SourceTable),
      TargetCall = call_info(Wrapper,Table),
      Dependency = dependency(SourceCall,Cont,TargetCall),

src/lib/tabling/batched_worklist.pl

@@ -45,8 +45,8 @@
 	    wkl_worklist_work_done/1			% +WorkList
 	  ]).
 
-:- use_module(global_worklist).
-:- use_module(double_linked_list).
+:- use_module(library(tabling/global_worklist)).
+:- use_module(library(tabling/double_linked_list)).
 
 :- use_module(library(atts)).
 :- use_module(library(lists)).
@@ -291,7 +291,7 @@ wkl_add_to_existing_answer_cluster(Worklist, Answer) :-
 wkl_add_to_new_answer_cluster(
     wkl_worklist(Dll,_Ria,_FlagExecutingWork,_AlreadyInMetaworklist,_TableIdentifier),
     Answer,AnswerClusterPointer
-) :-  
+) :-
     dll_append_left(Dll,wkl_answer_cluster(AnswerFlag),AnswerClusterPointer),
     put_atts(AnswerFlag, wkl_answer_cluster([Answer])).
 

src/lib/tabling/table_data_structure.pl

@@ -15,8 +15,8 @@
 	    get_nb_identifiers/3                % +Table, -NbWorklistID, -NbAnswerTreeID
 	  ]).
 
-:- use_module(table_link_manager).
-:- use_module(trie).
+:- use_module(library(tabling/table_link_manager)).
+:- use_module(library(tabling/trie)).
 
 /*  Part of SWI-Prolog
 
@@ -53,7 +53,7 @@
     POSSIBILITY OF SUCH DAMAGE.
 */
 
-:- use_module(batched_worklist).
+:- use_module(library(tabling/batched_worklist)).
 
 :- use_module(library(atts)).
 :- use_module(library(gensym)).

src/lib/tabling/table_link_manager.pl

@@ -47,7 +47,7 @@
 :- use_module(library(iso_ext)).
 :- use_module(library(terms)).
 
-:- use_module(trie).
+:- use_module(library(tabling/trie)).
 
 :- attribute trie_table_link/1.
 

src/lib/tabling/trie.pl

@@ -66,7 +66,7 @@
 % p_trie_arity_univ(+Term,-FunctorData,-ArgumentsList).
 p_trie_arity_univ(Term,functor_data(Name,Arity),Arguments) :-
   (  var(Term) ->
-     Name = var,
+     Name = Term,
      Arity = 0,
      Arguments = []
   ;  Term =.. [Name|Arguments],

src/lib/time.pl

@@ -0,0 +1,129 @@
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Written 2020 by Markus Triska (triska@metalevel.at)
+   Part of Scryer Prolog.
+
+   This library provides predicates for reasoning about time.
+
+   current_time(T) yields the current system time in an opaque form,
+   called a time stamp. Use format_time//2 to describe strings that
+   contain attributes of the time stamp.
+
+   The nonterminal format_time//2 describes a list of characters that
+   are formatted according to a format string. Usage:
+
+     phrase(format_time(FormatString, TimeStamp), Cs)
+
+   TimeStamp represents a moment in time in an opaque form, as for
+   example obtained by current_time/1.
+
+   FormatString is a list of characters that are interpreted literally,
+   except for the following specifiers (and possibly more in the future):
+
+     %Y    year of the time stamp. Example: 2020.
+     %m    month number (01-12), zero-padded to 2 digits
+     %d    day number (01-31), zero-padded to 2 digits
+     %H    hour number (00-24), zero-padded to 2 digits
+     %M    minute number (00-59), zero-padded to 2 digits
+     %S    second number (00-60), zero-padded to 2 digits
+     %b    abbreviated month name, always 3 letters
+     %a    abbreviated weekday name, always 3 letters
+     %A    full weekday name
+     %j    day of the year (001-366), zero-padded to 3 digits
+     %%    the literal %
+
+   Example:
+
+     ?- current_time(T), phrase(format_time("%d.%m.%Y (%H:%M:%S)", T), Cs).
+        T = [...], Cs = "11.06.2020 (00:24:32)"
+     ;  false.
+
+   sleep(S) sleeps for S seconds (a floating point number).
+
+   time(Goal) reports the execution time of Goal.
+
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+:- module(time, [max_sleep_time/1, sleep/1, time/1, current_time/1, format_time//2]).
+
+:- use_module(library(format)).
+:- use_module(library(iso_ext)).
+:- use_module(library(error)).
+:- use_module(library(dcgs)).
+:- use_module(library(lists)).
+:- use_module(library(charsio), [read_term_from_chars/2]).
+
+current_time(T) :-
+        '$current_time'(T0),
+        read_term_from_chars(T0, T).
+
+format_time([], _) --> [].
+format_time(['%','%'|Fs], T) --> !, "%", format_time(Fs, T).
+format_time(['%',Spec|Fs], T) --> !,
+        (   { member(Spec=Value, T) } ->
+            list(Value)
+        ;   { domain_error(time_specifier, Spec, format_time//2) }
+        ),
+        format_time(Fs, T).
+format_time([F|Fs], T) --> [F], format_time(Fs, T).
+
+list([]) --> [].
+list([L|Ls]) --> [L], list(Ls).
+
+max_sleep_time(0xfffffffffffffbff).
+
+sleep(T) :-
+    builtins:must_be_number(T, sleep),
+    (   T < 0 ->
+        domain_error(not_less_than_zero, T, sleep/1)
+    ;   max_sleep_time(N), T > N ->
+        throw(error(representation_error(max_sleep_time), sleep/1))
+    ;   '$sleep'(T)
+    ).
+
+
+% '$cpu_now' can be replaced by statistics/2 once that is implemented.
+
+time(Goal) :-
+        '$cpu_now'(T0),
+        setup_call_cleanup(true,
+                           (   Goal,
+                               report_time(T0)
+                           ),
+                           report_time(T0)).
+
+report_time(T0) :-
+        '$cpu_now'(T),
+        Time is T - T0,
+        (   bb_get('$first_answer', true) ->
+            format("   % CPU time: ~3f seconds~n", [Time])
+        ;   format("% CPU time: ~3f seconds~n   ", [Time])
+        ).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+?- time((true;false)).
+   % CPU time: 0.000 seconds
+   true
+;  % CPU time: 0.001 seconds
+   false.
+
+:- time(use_module(library(clpz))).
+   % CPU time: 2.762 seconds
+   true
+;  false.
+
+:- time(use_module(library(lists))).
+   % CPU time: 0.000 seconds
+   true
+;  % CPU time: 0.001 seconds
+   false.
+
+?- time(member(X, [a,b,c])).
+   % CPU time: 0.000 seconds
+   X = a
+;  % CPU time: 0.002 seconds
+   X = b
+;  % CPU time: 0.004 seconds
+   X = c
+;  % CPU time: 0.007 seconds
+   false.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

src/lib/xpath.pl

@@ -0,0 +1,642 @@
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   The original copyright and licence information is shown below.
+
+   Adapted in June 2020 by Markus Triska (triska@metalevel.at)
+   Part of Scryer Prolog.
+
+   In order to improve portability and reliability of this library, I
+   have changed various parts of the original code to make it
+   conforming to the Prolog ISO standard. I have removed all
+   occurrences of proprietary non-standard ad hoc data types.
+
+   In Scryer Prolog, we represent strings as lists of characters.
+   This makes them amenable to processing with DCGs and other
+   built-in mechanisms such as existing predicates on lists.
+   Scryer Prolog represents lists of characters very compactly,
+   making it an ideal representation for large amounts of text. It
+   fully conforms to the ISO standard and is very portable.
+
+   This library is intended to be used in tandem with load_html/3
+   from library(sgml), which creates DOM trees from markup documents.
+   It can be combined with http_open/3 from library(http/http_open)
+   to read such documents directly from network connections.
+
+   For instance, to inspect all links to Prolog files (*.pl) on
+   Scryer Prolog's project page, we can use:
+
+      :- use_module(library(http/http_open)).
+      :- use_module(library(sgml)).
+      :- use_module(library(lists)).
+      :- use_module(library(xpath)).
+
+      link_to_pl_file(File) :-
+          http_open("https://github.com/mthom/scryer-prolog", S, []),
+          load_html(stream(S), DOM, []),
+          xpath(DOM, //a(@href), File),
+          append(_, ".pl", File).
+
+   Yielding:
+
+      ?- link_to_pl_file(File).
+      %@    File = "/mthom/scryer-prolog/blob/master/src/lib/tabling.pl"
+      %@ ;  File = "/mthom/scryer-prolog/blob/master/src/lib/dif.pl"
+      %@ ;  File = "/mthom/scryer-prolog/blob/master/src/lib/freeze.pl"
+      %@ ;  ...
+
+   Parts of the original functionality may not yet work. Please
+   consider such parts opportunities for improvements, and file
+   issues in case you need additional features.
+
+   The original copyright information follows.
+
+   ======================================================================
+
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2009-2019, University of Amsterdam
+                              VU University Amsterdam
+                              CWI, Amsterdam
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the
+       distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+:- module(xpath,
+          [ xpath/3,                    % +DOM, +Spec, -Value
+            xpath_chk/3,                % +DOM, +Spec, -Value
+
+            op(400, fx, //),
+            op(400, fx, /),
+            op(200, fy, @)
+          ]).
+
+:- use_module(library(lists),[member/2,memberchk/2]).
+:- use_module(library(error)).
+:- use_module(library(dcgs)).
+:- use_module(library(si)).
+
+/** <module> Select nodes in an XML DOM
+
+The library xpath.pl provides predicates to select nodes from an XML DOM
+tree as produced by library(sgml) based  on descriptions inspired by the
+XPath language.
+
+The   predicate   xpath/3   selects   a   sub-structure   of   the   DOM
+non-deterministically based on an  XPath-like   specification.  Not  all
+selectors of XPath are implemented, but the ability to mix xpath/3 calls
+with arbitrary Prolog code  provides  a   powerful  tool  for extracting
+information from XML parse-trees.
+
+@see http://www.w3.org/TR/xpath
+*/
+
+element_name(element(Name,_,_), Name).
+element_attributes(element(_,Attributes,_), Attributes).
+element_content(element(_,_,Content), Content).
+
+%!  xpath_chk(+DOM, +Spec, ?Content) is semidet.
+%
+%   Semi-deterministic version of xpath/3.
+
+xpath_chk(DOM, Spec, Content) :-
+    xpath(DOM, Spec, Content),
+    !.
+
+%!  xpath(+DOM, +Spec, ?Content) is nondet.
+%
+%   Match an element in a DOM structure.   The syntax is inspired by
+%   XPath, using () rather than  []   to  select  inside an element.
+%   First we can construct paths using / and //:
+%
+%       $ =|//|=Term :
+%       Select any node in the DOM matching term.
+%       $ =|/|=Term :
+%       Match the root against Term.
+%       $ Term :
+%       Select the immediate children of the root matching Term.
+%
+%   The Terms above are of type   _callable_.  The functor specifies
+%   the element name. The element name   '*'  refers to any element.
+%   The name =self= refers to the   top-element  itself and is often
+%   used for processing matches of an  earlier xpath/3 query. A term
+%   NS:Term refers to an XML  name   in  the  namespace NS. Optional
+%   arguments specify additional  constraints   and  functions.  The
+%   arguments are processed from left  to right. Defined conditional
+%   argument values are:
+%
+%       $ index(?Index) :
+%       True if the element is the Index-th child of its parent,
+%       where 1 denotes the first child. Index can be one of:
+%         $ `Var` :
+%         `Var` is unified with the index of the matched element.
+%         $ =last= :
+%         True for the last element.
+%         $ =last= - `IntExpr` :
+%         True for the last-minus-nth element. For example,
+%         `last-1` is the element directly preceding the last one.
+%         $ `IntExpr` :
+%         True for the element whose index equals `IntExpr`.
+%       $ Integer :
+%       The N-th element with the given name, with 1 denoting the
+%       first element. Same as index(Integer).
+%       $ =last= :
+%       The last element with the given name. Same as
+%       index(last).
+%       $ =last= - IntExpr :
+%       The IntExpr-th element before the last.
+%       Same as index(last-IntExpr).
+%
+%   Defined function argument values are:
+%
+%       $ =self= :
+%       Evaluate to the entire element
+%       $ =content= :
+%       Evaluate to the content of the element (a list)
+%       $ =text= :
+%       Evaluates to all text from the sub-tree, represented
+%       as a list of characters.
+%       $ `text(atom)` :
+%       Evaluates to all text from the sub-tree as an atom.
+%       $ =normalize_space= :
+%       As =text=, but uses normalize_space/2 to normalise
+%       white-space in the output
+%       $ =number= :
+%       Extract an integer or float from the value.  Ignores
+%       leading and trailing white-space
+%       $ =|@|=Attribute :
+%       Evaluates to the value of the given attribute.  Attribute
+%       can be a compound term. In this case the functor name
+%       denotes the element and arguments perform transformations
+%       on the attribute value.  Defined transformations are:
+%
+%         - number
+%         Translate the value into a number using
+%         xsd_number_chars/2.
+%         - integer
+%         As `number`, but subsequently transform the value
+%         into an integer using the round/1 function.
+%         - float
+%         As `number`, but subsequently transform the value
+%         into a float using the float/1 function.
+%         - lower
+%         Translate the value to lower case, preserving
+%         the type.
+%         - upper
+%         Translate the value to upper case, preserving
+%         the type.
+%
+%   In addition, the argument-list can be _conditions_:
+%
+%       $ Left = Right :
+%       Succeeds if the left-hand unifies with the right-hand.
+%       If the left-hand side is a function, this is evaluated.
+%       The right-hand side is _never_ evaluated, and thus the
+%       condition `content = content` defines that the content
+%       of the element is the atom `content`.
+%       The functions `lower_case` and `upper_case` can be applied
+%       to Right (see example below).
+%       $ contains(Haystack, Needle) :
+%       Succeeds if Needle is a sub-list of Haystack.
+%       $ XPath :
+%       Succeeds if XPath matches in the currently selected
+%       sub-DOM.  For example, the following expression finds
+%       an =h3= element inside a =div= element, where the =div=
+%       element itself contains an =h2= child with a =strong=
+%       child.
+%
+%         ==
+%         //div(h2/strong)/h3
+%         ==
+%
+%       This is equivalent to the conjunction of XPath goals below.
+%
+%         ==
+%            ...,
+%            xpath(DOM, //(div), Div),
+%            xpath(Div, h2/strong, _),
+%            xpath(Div, h3, Result)
+%         ==
+%
+%   **Examples**:
+%
+%   Match each table-row in DOM:
+%
+%       ==
+%       xpath(DOM, //tr, TR)
+%       ==
+%
+%   Match the last cell  of  each   tablerow  in  DOM.  This example
+%   illustrates that a result can be the input of subsequent xpath/3
+%   queries. Using multiple queries  on   the  intermediate  TR term
+%   guarantee that all results come from the same table-row:
+%
+%       ==
+%       xpath(DOM, //tr, TR),
+%       xpath(TR,  /td(last), TD)
+%       ==
+%
+%   Match each =href= attribute in an <a> element
+%
+%       ==
+%       xpath(DOM, //a(@href), HREF)
+%       ==
+%
+%   Suppose we have a table containing  rows where each first column
+%   is the name of a product with a   link to details and the second
+%   is the price (a number).  The   following  predicate matches the
+%   name, URL and price:
+%
+%       ==
+%       product(DOM, Name, URL, Price) :-
+%           xpath(DOM, //tr, TR),
+%           xpath(TR, td(1), C1),
+%           xpath(C1, /self(normalize_space), Name),
+%           xpath(C1, a(@href), URL),
+%           xpath(TR, td(2, number), Price).
+%       ==
+%
+%   Suppose we want to select  books   with  genre="thriller" from a
+%   tree containing elements =|<book genre=...>|=
+%
+%       ==
+%       thriller(DOM, Book) :-
+%           xpath(DOM, //book(@genre=thiller), Book).
+%       ==
+%
+%   Match the elements =|<table align="center">|= _and_ =|<table
+%   align="CENTER">|=:
+%
+%       ```prolog
+%           //table(@align(lower) = center)
+%       ```
+%
+%   Get the `width` and `height` of a `div` element as a number,
+%   and the `div` node itself:
+%
+%       ==
+%           xpath(DOM, //div(@width(number)=W, @height(number)=H), Div)
+%       ==
+%
+%   Note that `div` is an infix operator, so parentheses must be
+%   used in cases like the following:
+%
+%       ==
+%           xpath(DOM, //(div), Div)
+%       ==
+
+xpath(DOM, Spec, Content) :-
+    in_dom(Spec, DOM, Content).
+
+in_dom(//Spec, DOM, Value) :-
+    !,
+    element_spec(Spec, Name, Modifiers),
+    sub_dom(I, Len, Name, E, DOM),
+    modifiers(Modifiers, I, Len, E, Value).
+in_dom(/Spec, E, Value) :-
+    !,
+    element_spec(Spec, Name, Modifiers),
+    (   Name == self
+    ->  true
+    ;   element_name(E, Name)
+    ),
+    modifiers(Modifiers, 1, 1, E, Value).
+in_dom(A/B, DOM, Value) :-
+    !,
+    in_dom(A, DOM, Value0),
+    in_dom(B, Value0, Value).
+in_dom(A//B, DOM, Value) :-
+    !,
+    in_dom(A, DOM, Value0),
+    in_dom(//B, Value0, Value).
+in_dom(Spec, element(_, _, Content), Value) :-
+    element_spec(Spec, Name, Modifiers),
+    count_named_elements(Content, Name, CLen),
+    CLen > 0,
+    nth_element(N, Name, E, Content),
+    modifiers(Modifiers, N, CLen, E, Value).
+
+element_spec(Var, _, _) :-
+    var(Var),
+    !,
+    instantiation_error(Var).
+element_spec(NS:Term, NS:Name, Modifiers) :-
+    !,
+    callable_name_arguments(Term, Name0, Modifiers),
+    star(Name0, Name).
+element_spec(Term, Name, Modifiers) :-
+    !,
+    callable_name_arguments(Term, Name0, Modifiers),
+    star(Name0, Name).
+
+callable_name_arguments(Atom, Name, Arguments) :-
+    atom(Atom),
+    !,
+    Name = Atom, Arguments = [].
+callable_name_arguments(Compound, Name, Arguments) :-
+    Compound =.. [Name|Arguments].
+
+
+star(*, _) :- !.
+star(Name, Name).
+
+
+%!  sub_dom(-Index, -Count, +Name, -Sub, +DOM) is nondet.
+%
+%   Sub is a node in DOM with Name.
+%
+%   @param Count    is the total number of nodes in the content
+%                   list Sub appears that have the same name.
+%   @param Index    is the 1-based index of Sub of nodes with
+%                   Name.
+
+sub_dom(1, 1, Name, DOM, DOM) :-
+    element_name(DOM, Name0),
+    \+ Name \= Name0.
+sub_dom(N, Len, Name, E, element(_,_,Content)) :-
+    !,
+    sub_dom_2(N, Len, Name, E, Content).
+sub_dom(N, Len, Name, E, Content) :-
+    list_si(Content),
+    sub_dom_2(N, Len, Name, E, Content).
+
+sub_dom_2(N, Len, Name, Element, Content) :-
+    (   count_named_elements(Content, Name, Len),
+        nth_element(N, Name, Element, Content)
+    ;   member(element(_,_,C2), Content),
+        sub_dom_2(N, Len, Name, Element, C2)
+    ).
+
+
+%!  count_named_elements(+Content, +Name, -Count) is det.
+%
+%   Count is the number of nodes with Name in Content.
+
+count_named_elements(Content, Name, Count) :-
+    count_named_elements(Content, Name, 0, Count).
+
+count_named_elements([], _, Count, Count).
+count_named_elements([element(Name,_,_)|T], Name0, C0, C) :-
+    \+ Name \= Name0,
+    !,
+    C1 is C0+1,
+    count_named_elements(T, Name0, C1, C).
+count_named_elements([_|T], Name, C0, C) :-
+    count_named_elements(T, Name, C0, C).
+
+
+%!  nth_element(?N, +Name, -Element, +Content:list) is nondet.
+%
+%   True if Element is the N-th element with name in Content.
+
+nth_element(N, Name, Element, Content) :-
+    nth_element_(1, N, Name, Element, Content).
+
+nth_element_(I, N, Name, E, [H|T]) :-
+    element_name(H, Name0),
+    \+ Name \= Name0,
+    !,
+    (   N = I,
+        E = H
+    ;   I2 is I + 1,
+        (   nonvar(N), I2 > N
+        ->  !, fail
+        ;   true
+        ),
+        nth_element_(I2, N, Name, E, T)
+    ).
+nth_element_(I, N, Name, E, [_|T]) :-
+    nth_element_(I, N, Name, E, T).
+
+
+%!  modifiers(+Modifiers, +I, +Clen, +DOM, -Value)
+%
+%
+
+modifiers([], _, _, Value, Value).
+modifiers([H|T], I, L, Value0, Value) :-
+    modifier(H, I, L, Value0, Value1),
+    modifiers(T, I, L, Value1, Value).
+
+modifier(M, _, _, _, _) :-
+    var(M),
+    !,
+    instantiation_error(M).
+modifier(Index, I, L, Value0, Value) :-
+    implicit_index_modifier(Index),
+    !,
+    Value = Value0,
+    index_modifier(Index, I, L).
+modifier(index(Index), I, L, Value, Value) :-
+    !,
+    index_modifier(Index, I, L).
+modifier(Function, _, _, In, Out) :-
+    xpath_function(Function),
+    !,
+    xpath_function(Function, In, Out).
+modifier(Function, _, _, In, Out) :-
+    xpath_condition(Function, In),
+    Out = In.
+
+implicit_index_modifier(I) :-
+    integer(I),
+    !.
+implicit_index_modifier(last).
+implicit_index_modifier(last-_Expr).
+
+index_modifier(Var, I, _L) :-
+    var(Var),
+    !,
+    Var = I.
+index_modifier(last, I, L) :-
+    !,
+    I =:= L.
+index_modifier(last-Expr, I, L) :-
+    !,
+    I =:= L-Expr.
+index_modifier(N, I, _) :-
+    N =:= I.
+
+xpath_function(self, DOM, DOM).                                % self
+xpath_function(content, Element, Value) :-                     % content
+    element_content(Element, Value).
+xpath_function(text, DOM, Text) :-                             % text
+    text_of_dom(DOM, chars, Text).
+xpath_function(text(As), DOM, Text) :-                         % text(atom)
+    text_of_dom(DOM, As, Text).
+xpath_function(normalize_space, DOM, Text) :-                  % normalize_space
+    text_of_dom(DOM, chars, Text0),
+    normalize_space(Text0, Text).
+xpath_function(number, DOM, Number) :-                         % number
+    text_of_dom(DOM, chars, Text0),
+    normalize_space(Text0, Text),
+    catch(xsd_number_chars(Number, Text), _, fail).
+xpath_function(@Name, element(_, Attrs, _), Value) :-          % @Name
+    (   atom(Name)
+    ->  memberchk(Name=Value, Attrs)
+    ;   compound(Name)
+    ->  Name =.. [AName|AOps],
+        memberchk(AName=Value0, Attrs),
+        translate_attribute(AOps, Value0, Value)
+    ;   member(Name=Value, Attrs)
+    ).
+xpath_function(quote(Value), _, Value).                         % quote(Value)
+
+xpath_function(self).
+xpath_function(content).
+xpath_function(text).
+xpath_function(text(_)).
+xpath_function(normalize_space).
+xpath_function(number).
+xpath_function(@_).
+xpath_function(quote(_)).
+
+translate_attribute([], Value, Value).
+translate_attribute([H|T], Value0, Value) :-
+    translate_attr(H, Value0, Value1),
+    translate_attribute(T, Value1, Value).
+
+translate_attr(number, Value0, Value) :-
+    xsd_number_chars(Value, Value0).
+translate_attr(integer, Value0, Value) :-
+    xsd_number_chars(Value1, Value0),
+    Value is round(Value1).
+translate_attr(float, Value0, Value) :-
+    xsd_number_chars(Value1, Value0),
+    Value is float(Value1).
+% The implementation of these translations is left for later.
+% translate_attr(lower, Value0, Value) :- ...
+% translate_attr(upper, Value0, Value) :- ...
+
+xpath_condition(Left = Right, Value) :-                        % =
+    !,
+    var_or_function(Left, Value, LeftValue),
+    process_equality(LeftValue, Right).
+xpath_condition(contains(Haystack, Needle), Value) :-          % contains(Haystack, Needle)
+    !,
+    val_or_function(Haystack, Value, HaystackValue),
+    val_or_function(Needle, Value, NeedleValue),
+    (   phrase((list(_),list(NeedleValue),list(_)), HaystackValue)
+    ->  true
+    ).
+xpath_condition(Spec, Dom) :-
+    in_dom(Spec, Dom, _).
+
+
+%!  process_equality(+Left, +Right) is semidet.
+%
+%   Provides (very) partial support for XSLT   functions that can be
+%   applied according to the XPath 2 specification.
+%
+%   For example the XPath expression  in   [1],  and  the equivalent
+%   Prolog expression in [2], would both   match the HTML element in
+%   [3].
+%
+%     ==
+%     [1] //table[align=lower-case(center)]
+%     [2] //table(@align=lower_case(center))
+%     [3] <table align="CENTER">
+%     ==
+
+process_equality(Left, Right) :-
+    var(Right),
+    !,
+    Left = Right.
+process_equality(Left, lower_case(Right)) :-
+    !,
+    downcase_atom(Left, Right).
+process_equality(Left, upper_case(Right)) :-
+    !,
+    upcase_atom(Left, Right).
+process_equality(Left, Right) :-
+    Left = Right.
+
+
+var_or_function(Arg, _, Arg) :-
+    var(Arg),
+    !.
+var_or_function(Func, Value0, Value) :-
+    xpath_function(Func),
+    !,
+    xpath_function(Func, Value0, Value).
+var_or_function(Value, _, Value).
+
+val_or_function(Arg, _, Arg) :-
+    var(Arg),
+    !,
+    instantiation_error(Arg).
+val_or_function(Func, Value0, Value) :-                         % TBD
+    xpath_function(Func, Value0, Value),
+    !.
+val_or_function(Value, _, Value).
+
+
+%!  text_of_dom(+DOM, +As, -Text:(chars | atom)) is det.
+%
+%   Text is the joined textual content of DOM.
+
+text_of_dom(DOM, As, Text) :-
+    phrase(text_of(DOM), Text0),
+    (   As == chars ->
+        Text = Text0
+    ;   As == atom ->
+        atom_chars(Text, Text0)
+    ;   domain_error(As, atom_or_chars, xpath)
+    ).
+
+text_of(element(_,_,Content)) -->
+    text_of_list(Content).
+text_of([]) -->
+    [].
+text_of([H|T]) -->
+    text_of(H),
+    text_of(T).
+
+
+text_of_list([]) -->
+    [].
+text_of_list([H|T]) -->
+    text_of_1(H),
+    text_of_list(T).
+
+
+text_of_1(element(_,_,Content)) -->
+        text_of_list(Content).
+text_of_1([C|Cs]) --> list([C|Cs]).
+
+list([]) --> [].
+list([L|Ls]) --> [L], list(Ls).
+
+% For now, we use number_chars/2 to parse XML numbers.
+% If the need arises, we can extend this to additional
+% float constants and syntax that may occur in XML files.
+
+xsd_number_chars(Number, Chars) :-
+        number_chars(Number, Chars).
+
+normalize_space(Text0, Text) :-
+        Text0 = Text.           % no conversion for the moment.

src/machine/arithmetic_ops.rs

@@ -1,13 +1,15 @@
+use crate::divrem::*;
+
 use crate::prolog_parser::ast::*;
 
-use crate::prolog::arithmetic::*;
-use crate::prolog::clause_types::*;
-use crate::prolog::forms::*;
-use crate::prolog::machine::machine_errors::*;
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::machine::machine_state::*;
-use crate::prolog::ordered_float::*;
-use crate::prolog::rug::{Integer, Rational};
+use crate::arithmetic::*;
+use crate::clause_types::*;
+use crate::forms::*;
+use crate::machine::machine_errors::*;
+use crate::machine::machine_indices::*;
+use crate::machine::machine_state::*;
+use crate::ordered_float::*;
+use crate::rug::{Integer, Rational};
 
 use std::cmp;
 use std::convert::TryFrom;
@@ -141,12 +143,10 @@ impl MachineState {
 
     pub(crate)
     fn arith_eval_by_metacall(&self, r: RegType) -> Result<Number, MachineStub> {
-        let a = self[r].clone();
-
-        let caller = MachineError::functor_stub(clause_name!("(is)"), 2);
+        let caller = MachineError::functor_stub(clause_name!("is"), 2);
         let mut interms: Vec<Number> = Vec::with_capacity(64);
 
-        for addr in self.post_order_iter(a) {
+        for addr in self.post_order_iter(self[r]) {
             match self.heap.index_addr(&addr).as_ref() {
                 &HeapCellValue::NamedStr(2, ref name, _) => {
                     let a2 = interms.pop().unwrap();
@@ -157,7 +157,7 @@ impl MachineState {
                         "-" => interms.push(try_numeric_result!(self, a1 - a2, caller)?),
                         "*" => interms.push(try_numeric_result!(self, a1 * a2, caller)?),
                         "/" => interms.push(self.div(a1, a2)?),
-                        "**" => interms.push(self.pow(a1, a2, "(is)")?),
+                        "**" => interms.push(self.pow(a1, a2, "is")?),
                         "^" => interms.push(self.int_pow(a1, a2)?),
                         "max" => interms.push(self.max(a1, a2)?),
                         "min" => interms.push(self.min(a1, a2)?),
@@ -189,7 +189,16 @@ impl MachineState {
                         "atan2" => interms.push(Number::Float(OrderedFloat(self.atan2(a1, a2)?))),
                         "gcd" => interms.push(self.gcd(a1, a2)?),
                         _ => {
-                            return Err(self.error_form(MachineError::instantiation_error(), caller))
+                            let evaluable_stub = MachineError::functor_stub(name.clone(), 2);
+
+                            return Err(self.error_form(
+                                MachineError::type_error(
+                                    self.heap.h(),
+                                    ValidType::Evaluable,
+                                    evaluable_stub,
+                                ),
+                                caller,
+                            ));
                         }
                     }
                 }
@@ -217,13 +226,19 @@ impl MachineState {
                         "\\" => interms.push(self.bitwise_complement(a1)?),
                         "sign" => interms.push(self.sign(a1)),
                         _ => {
-                            return Err(self.error_form(MachineError::instantiation_error(), caller));
+                            let evaluable_stub = MachineError::functor_stub(name.clone(), 1);
+
+                            return Err(self.error_form(
+                                MachineError::type_error(
+                                    self.heap.h(),
+                                    ValidType::Evaluable,
+                                    evaluable_stub,
+                                ),
+                                caller,
+                            ));
                         }
                     }
                 }
-                &HeapCellValue::Addr(Addr::CharCode(n)) => {
-                    interms.push(Number::Integer(Rc::new(Integer::from(n))));
-                }
                 &HeapCellValue::Addr(Addr::Fixnum(n)) => {
                     interms.push(Number::Fixnum(n));
                 }
@@ -242,12 +257,44 @@ impl MachineState {
                 &HeapCellValue::Atom(ref name, _) if name.as_str() == "pi" => {
                     interms.push(Number::Float(OrderedFloat(f64::consts::PI)))
                 }
-                _ => {
+                &HeapCellValue::NamedStr(arity, ref name, _) => {
+                    let evaluable_stub = MachineError::functor_stub(name.clone(), arity);
+
+                    return Err(self.error_form(
+                        MachineError::type_error(
+                            self.heap.h(),
+                            ValidType::Evaluable,
+                            evaluable_stub,
+                        ),
+                        caller,
+                    ));
+                }
+                &HeapCellValue::Atom(ref name, _) => {
+                    let evaluable_stub = MachineError::functor_stub(name.clone(), 0);
+
+                    return Err(self.error_form(
+                        MachineError::type_error(
+                            self.heap.h(),
+                            ValidType::Evaluable,
+                            evaluable_stub,
+                        ),
+                        caller,
+                    ));
+                }
+                &HeapCellValue::Addr(addr) if addr.is_ref() => {
                     return Err(self.error_form(
                         MachineError::instantiation_error(),
                         caller,
                     ));
                 }
+                val => {
+                    return Err(self.type_error(
+                        ValidType::Number,
+                        val.context_free_clone(),
+                        clause_name!("is"),
+                        2,
+                    ));
+                }
             }
         }
 
@@ -266,20 +313,10 @@ impl MachineState {
 
     pub(crate)
     fn int_floor_div(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
-        match n1 / n2 {
-            Ok(result) => {
-                Ok(rnd_i(&result).to_owned())
-            }
-            Err(e) => {
-                let stub = MachineError::functor_stub(clause_name!("(div)"), 2);
-                Err(self.error_form(
-                    MachineError::evaluation_error(
-                        e
-                    ),
-                    stub
-                ))
-            }
-        }
+        let stub = MachineError::functor_stub(clause_name!("(div)"), 2);
+        let modulus = self.modulus(n1.clone(), n2.clone())?;
+
+        self.idiv(try_numeric_result!(self, n1 - modulus, stub)?, n2)
     }
 
     pub(crate)
@@ -388,7 +425,7 @@ impl MachineState {
 
     pub(crate)
     fn atan2(&self, n1: Number, n2: Number) -> Result<f64, MachineStub> {
-        let stub = MachineError::functor_stub(clause_name!("(is)"), 2);
+        let stub = MachineError::functor_stub(clause_name!("is"), 2);
 
         if n1.is_zero() && n2.is_zero() {
             Err(self.error_form(MachineError::evaluation_error(EvalError::Undefined), stub))
@@ -403,13 +440,13 @@ impl MachineState {
     pub(crate)
     fn int_pow(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
         if n1.is_zero() && n2.is_negative() {
-            let stub = MachineError::functor_stub(clause_name!("(is)"), 2);
+            let stub = MachineError::functor_stub(clause_name!("is"), 2);
             return Err(self.error_form(MachineError::evaluation_error(EvalError::Undefined), stub));
         }
 
         match (n1, n2) {
             (Number::Fixnum(n1), Number::Fixnum(n2)) => {
-                if n1 != 1 && n2 < 0 {
+                if !(n1 == 1 || n1 == 0 || n1 == -1) && n2 < 0 {
                     let n = Number::from(n1);
                     let stub = MachineError::functor_stub(clause_name!("^"), 2);
 
@@ -435,7 +472,7 @@ impl MachineState {
                 }
             }
             (Number::Fixnum(n1), Number::Integer(n2)) => {
-                if n1 != 1 && &*n2 < &0 {
+                if !(n1 == 1 || n1 == 0 || n1 == -1) && &*n2 < &0 {
                     let n = Number::from(n1);
                     let stub = MachineError::functor_stub(clause_name!("^"), 2);
 
@@ -453,7 +490,7 @@ impl MachineState {
                 }
             }
             (Number::Integer(n1), Number::Fixnum(n2)) => {
-                if &*n1 != &1 && n2 < 0 {
+                if !(&*n1 == &1 || &*n1 == &0 || &*n1 == &-1) && n2 < 0 {
                     let n = Number::Integer(n1);
                     let stub = MachineError::functor_stub(clause_name!("^"), 2);
 
@@ -471,7 +508,7 @@ impl MachineState {
                 }
             }
             (Number::Integer(n1), Number::Integer(n2)) => {
-                if &*n1 != &1 && &*n2 < &0 {
+                if !(&*n1 == &1 || &*n1 == &0 || &*n1 == &-1) && &*n2 < &0 {
                     let n = Number::Integer(n1);
                     let stub = MachineError::functor_stub(clause_name!("^"), 2);
 
@@ -498,7 +535,7 @@ impl MachineState {
                 let f2 = self.float(n2)?;
 
                 if n1.is_negative() && f2 != f2.floor() {
-                    let stub = MachineError::functor_stub(clause_name!("(is)"), 2);
+                    let stub = MachineError::functor_stub(clause_name!("is"), 2);
                     return Err(
                         self.error_form(MachineError::evaluation_error(EvalError::Undefined), stub)
                     );
@@ -582,34 +619,7 @@ impl MachineState {
             return Err(self.error_form(MachineError::evaluation_error(EvalError::Undefined), stub));
         }
 
-        match (n1, n2) {
-            (Number::Fixnum(n1), Number::Fixnum(n2)) => {
-                if let Ok(n2) = u32::try_from(n2) {
-                    if let Some(result) = n1.checked_pow(n2) {
-                        return Ok(Number::from(result));
-                    }
-                }
-
-                let n1 = Integer::from(n1);
-                let n2 = Integer::from(n2);
-
-                Ok(Number::from(binary_pow(n1, &n2)))
-            }
-            (Number::Fixnum(n1), Number::Integer(n2)) => {
-                let n1 = Integer::from(n1);
-                Ok(Number::from(binary_pow(n1, n2.as_ref())))
-            }
-            (Number::Integer(n1), Number::Fixnum(n2)) => {
-                let n2 = Integer::from(n2);
-                Ok(Number::from(binary_pow(n1.as_ref().clone(), &n2)))
-            }
-            (Number::Integer(n1), Number::Integer(n2)) => {
-                Ok(Number::from(binary_pow(n1.as_ref().clone(), &*n2)))
-            }
-            (n1, n2) => {
-                self.float_pow(n1, n2)
-            }
-        }
+        self.float_pow(n1, n2)
     }
 
     #[inline]
@@ -618,7 +628,7 @@ impl MachineState {
     where
         FloatFn: Fn(f64) -> f64,
     {
-        let stub = MachineError::functor_stub(clause_name!("(is)"), 2);
+        let stub = MachineError::functor_stub(clause_name!("is"), 2);
 
         let f1 = try_numeric_result!(self, result_f(&n1, rnd_f), stub)?;
         let f1 = result_f(&Number::Float(OrderedFloat(f(f1))), rnd_f);
@@ -678,7 +688,7 @@ impl MachineState {
     pub(crate)
     fn sqrt(&self, n1: Number) -> Result<f64, MachineStub> {
         if n1.is_negative() {
-            let stub = MachineError::functor_stub(clause_name!("(is)"), 2);
+            let stub = MachineError::functor_stub(clause_name!("is"), 2);
             return Err(self.error_form(MachineError::evaluation_error(EvalError::Undefined), stub));
         }
 
@@ -688,7 +698,7 @@ impl MachineState {
     #[inline]
     pub(crate)
     fn float(&self, n: Number) -> Result<f64, MachineStub> {
-        let stub = MachineError::functor_stub(clause_name!("(is)"), 2);
+        let stub = MachineError::functor_stub(clause_name!("is"), 2);
         try_numeric_result!(self, result_f(&n, rnd_f), stub)
     }
 
@@ -716,7 +726,7 @@ impl MachineState {
 
     pub(crate)
     fn round(&self, n: Number) -> Result<Number, MachineStub> {
-        let stub = MachineError::functor_stub(clause_name!("(is)"), 2);
+        let stub = MachineError::functor_stub(clause_name!("is"), 2);
 
         let result = n + Number::Float(OrderedFloat(0.5f64));
         let result = try_numeric_result!(self, result, stub)?;
@@ -730,18 +740,12 @@ impl MachineState {
 
         match (n1, n2) {
             (Number::Fixnum(n1), Number::Fixnum(n2)) => {
-                if let Ok(n2) = u32::try_from(n2) {
-                    if let Some(result) = n1.checked_shr(n2) {
-                        return Ok(Number::from(result));
-                    }
-                }
-
                 let n1 = Integer::from(n1);
-                let n2 = Integer::from(n2);
 
-                match n2.to_u32() {
-                    Some(n2) => Ok(Number::from(n1 >> n2)),
-                    _ => Ok(Number::from(n1 >> u32::max_value())),
+                if let Ok(n2) = u32::try_from(n2) {
+                    return Ok(Number::from(n1 >> n2));
+                } else {
+                    return Ok(Number::from(n1 >> u32::max_value()));
                 }
             }
             (Number::Fixnum(n1), Number::Integer(n2)) => {
@@ -788,18 +792,12 @@ impl MachineState {
 
         match (n1, n2) {
             (Number::Fixnum(n1), Number::Fixnum(n2)) => {
-                if let Ok(n2) = u32::try_from(n2) {
-                    if let Some(result) = n1.checked_shl(n2) {
-                        return Ok(Number::from(result));
-                    }
-                }
-
                 let n1 = Integer::from(n1);
-                let n2 = Integer::from(n2);
 
-                match n2.to_u32() {
-                    Some(n2) => Ok(Number::from(n1 << n2)),
-                    _ => Ok(Number::from(n1 << u32::max_value())),
+                if let Ok(n2) = u32::try_from(n2) {
+                    return Ok(Number::from(n1 << n2));
+                } else {
+                    return Ok(Number::from(n1 << u32::max_value()));
                 }
             }
             (Number::Fixnum(n1), Number::Integer(n2)) => {
@@ -990,7 +988,7 @@ impl MachineState {
                         stub,
                     ))
                 } else {
-                    Ok(Number::from(n1 % n2))
+                    Ok(Number::from(n1.rem_floor(n2)))
                 }
             }
             (Number::Fixnum(n1), Number::Integer(n2)) => {

src/machine/attributed_variables.pl

@@ -1,3 +1,5 @@
+:- module('$atts', []).
+
 driver(Vars, Values) :-
     iterate(Vars, Values, ListOfListsOfGoalLists),
     !,

src/machine/attributed_variables.rs

@@ -1,4 +1,7 @@
-use crate::prolog::machine::*;
+use crate::heap_iter::*;
+use crate::machine::*;
+
+use crate::indexmap::IndexSet;
 
 use std::cmp::Ordering;
 use std::vec::IntoIter;
@@ -8,6 +11,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>,
@@ -136,4 +140,37 @@ impl MachineState {
         self.b0 = self.b;
         self.p = CodePtr::Local(LocalCodePtr::DirEntry(p));
     }
+
+    pub(super)
+    fn attr_vars_of_term(&self, addr: Addr) -> Vec<Addr> {
+        let mut seen_set  = IndexSet::new();
+        let mut seen_vars = vec![];
+
+        let mut iter = self.acyclic_pre_order_iter(addr);
+
+        while let Some(addr) = iter.next() {
+            if let HeapCellValue::Addr(Addr::AttrVar(h)) = self.heap.index_addr(&addr).as_ref() {
+                if seen_set.contains(h) {
+                    continue;
+                }
+
+                seen_vars.push(addr);
+                seen_set.insert(*h);
+
+                let mut l = h + 1;
+                let mut list_elements = vec![];
+
+                while let Addr::Lis(elem) = self.store(self.deref(Addr::HeapCell(l))) {
+                    list_elements.push(self.heap[elem].as_addr(elem));
+                    l = elem + 1;
+                }
+
+                for element in list_elements.into_iter().rev() {
+                    iter.stack().push(element);
+                }
+            }
+        }
+
+        seen_vars
+    }
 }

src/machine/code_repo.rs

@@ -1,17 +1,18 @@
-use crate::prolog::clause_types::*;
-use crate::prolog::codegen::*;
-use crate::prolog::debray_allocator::*;
-use crate::prolog::forms::*;
-use crate::prolog::instructions::*;
-use crate::prolog::machine::compile::*;
-use crate::prolog::machine::machine_errors::*;
-use crate::prolog::machine::machine_indices::*;
+use crate::clause_types::*;
+use crate::codegen::*;
+use crate::debray_allocator::*;
+use crate::forms::*;
+use crate::instructions::*;
+use crate::machine::compile::*;
+use crate::machine::machine_errors::*;
+use crate::machine::machine_indices::*;
 
-use indexmap::IndexSet;
+use crate::indexmap::IndexSet;
 
 use std::collections::VecDeque;
 use std::mem;
 
+#[derive(Debug)]
 pub struct CodeRepo {
     pub(super) cached_query: Code,
     pub(super) goal_expanders: Code,
@@ -52,15 +53,27 @@ impl CodeRepo {
         self.term_dir
             .get_mut(&key)
             .map(|entry| {
-                (
-                    Predicate((entry.0).0.drain(len..).collect()),
-                    entry.1.drain(queue_len..).collect(),
-                )
+                let terms =
+                    if len < (entry.0).0.len() {
+                        (entry.0).0.drain(len ..).collect()
+                    } else {
+                        vec![]
+                    };
+
+                let queue =
+                    if queue_len < entry.1.len() {
+                        entry.1.drain(queue_len ..).collect()
+                    } else {
+                        VecDeque::new()
+                    };
+
+                (Predicate(terms), queue)
             })
-            .unwrap_or((Predicate::new(), VecDeque::from(vec![])))
+            .unwrap_or((Predicate::new(), VecDeque::new()))
     }
 
-    pub(crate) fn add_in_situ_result(
+    pub(crate)
+    fn add_in_situ_result(
         &mut self,
         result: &CompiledResult,
         in_situ_code_dir: &mut InSituCodeDir,
@@ -100,16 +113,19 @@ impl CodeRepo {
     }
 
     #[inline]
-    pub(super) fn size_of_cached_query(&self) -> usize {
+    pub(super)
+    fn size_of_cached_query(&self) -> usize {
         self.cached_query.len()
     }
 
     #[inline]
-    pub(super) fn take_in_situ_code(&mut self) -> Code {
+    pub(super)
+    fn take_in_situ_code(&mut self) -> Code {
         mem::replace(&mut self.in_situ_code, Code::new())
     }
 
-    pub(super) fn lookup_instr<'a>(
+    pub(super)
+    fn lookup_instr<'a>(
         &'a self,
         last_call: bool,
         p: &CodePtr,

src/machine/code_walker.rs

@@ -1,4 +1,4 @@
-use crate::prolog::instructions::*;
+use crate::instructions::*;
 
 use std::collections::VecDeque;
 

src/machine/compile.rs

@@ -1,22 +1,22 @@
-use prolog_parser::ast::*;
-use prolog_parser::parser::get_desc;
-use prolog_parser::tabled_rc::TabledData;
+use crate::prolog_parser::ast::*;
+use crate::prolog_parser::parser::get_desc;
+use crate::prolog_parser::tabled_rc::TabledData;
 
-use crate::prolog::codegen::*;
-use crate::prolog::debray_allocator::*;
-use crate::prolog::forms::*;
-use crate::prolog::instructions::*;
-use crate::prolog::iterators::*;
-use crate::prolog::machine::code_walker::*;
-use crate::prolog::machine::machine_errors::*;
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::machine::term_expansion::ExpansionAdditionResult;
-use crate::prolog::machine::toplevel::*;
-use crate::prolog::machine::*;
+use crate::codegen::*;
+use crate::debray_allocator::*;
+use crate::forms::*;
+use crate::instructions::*;
+use crate::iterators::*;
+use crate::machine::code_walker::*;
+use crate::machine::machine_errors::*;
+use crate::machine::machine_indices::*;
+use crate::machine::term_expansion::ExpansionAdditionResult;
+use crate::machine::toplevel::*;
+use crate::machine::*;
 
-use indexmap::{IndexMap, IndexSet};
+use crate::indexmap::{IndexMap, IndexSet};
 
-use ref_thread_local::RefThreadLocal;
+use crate::ref_thread_local::RefThreadLocal;
 
 use std::cell::Cell;
 use std::collections::VecDeque;
@@ -77,9 +77,11 @@ fn load_module(
         listing_src.clone(),
     );
 
+    let mut stream = parsing_stream(stream)?;
+
     let results = compiler.gather_items(
         wam,
-        &mut parsing_stream(stream),
+        &mut stream,
         &mut indices,
     );
 
@@ -117,7 +119,7 @@ fn load_module_from_file(
     let mut path_buf = fix_filename(wam.indices.atom_tbl.clone(), path_buf)?;
     let filename = clause_name!(path_buf.to_string_lossy().to_string(), wam.indices.atom_tbl);
 
-    let file_handle = Stream::from(File::open(&path_buf).or_else(|_| {
+    let file_handle = Stream::from_file_as_input(filename.clone(), File::open(&path_buf).or_else(|_| {
         Err(SessionError::InvalidFileName(filename.clone()))
     })?);
 
@@ -188,6 +190,8 @@ fn set_first_index(code: &mut Code) {
                 if *offset == 0 =>
             {
                 *offset = code_len - idx;
+                debug_assert!(*offset > 0);
+
                 break;
             }
             _ => {}
@@ -344,12 +348,10 @@ fn compile_into_module(
     );
 
     match compile_into_module_impl(wam, &mut compiler, module, src, indices) {
-        Ok(()) => EvalSession::EntrySuccess,
+        Ok(()) => {
+            EvalSession::EntrySuccess
+        }
         Err(e) => {
-            if let Some(module) = compiler.module.take() {
-                wam.indices.insert_module(module);
-            }
-
             compiler.drop_expansions(&mut wam.code_repo);
             EvalSession::from(e)
         }
@@ -366,14 +368,16 @@ fn compile_into_module_impl(
     setup_module_expansions(wam, &module);
 
     let module_name = module.module_decl.name.clone();
-    compiler.module = Some(module);
+    // compiler.module = Some(module); This trips the goal expansion up. Should be possible to 'merge' modules.
+    // A much better strategy!
+    wam.indices.insert_module(module);
 
     wam.code_repo.compile_hook(CompileTimeHook::TermExpansion)?;
     wam.code_repo.compile_hook(CompileTimeHook::GoalExpansion)?;
 
     let mut results = compiler.gather_items(
         wam,
-        &mut parsing_stream(src),
+        &mut parsing_stream(src)?,
         &mut indices,
     )?;
 
@@ -395,10 +399,11 @@ fn compile_into_module_impl(
     clause_code_generator.generate_clause_code(&results.dynamic_clause_map, wam)?;
 
     let top_level_term_dir = results.top_level_term_dirs.consolidate();
+    let module = wam.indices.take_module(module_name).unwrap();
 
     add_module(
         wam,
-        compiler.module.take().unwrap(),
+        module,
         indices,
         top_level_term_dir,
     );
@@ -409,6 +414,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 +429,7 @@ pub struct GatherResult {
     in_situ_module_dir: ModuleStubDir,
 }
 
+#[derive(Debug)]
 pub struct ClauseCodeGenerator {
     len_offset: usize,
     code: Code,
@@ -462,6 +469,7 @@ impl ClauseCodeGenerator {
                             vec![Box::new(head.clone()), Box::new(tail.clone())],
                             None,
                         );
+
                         PredicateClause::Fact(clause, 0, 0)
                     })
                     .collect(),
@@ -529,6 +537,7 @@ fn insert_or_refresh_term_dir_quantum(
     }
 }
 
+#[derive(Debug)]
 pub struct ListingCompiler {
     module: Option<Module>,
     user_term_dir: TermDir,
@@ -593,12 +602,7 @@ fn load_library(
 ) -> Result<ClauseName, SessionError> {
     match LIBRARIES.borrow().get(name.as_str()) {
         Some(code) => {
-            let mut lib_path = current_dir();
-
-            lib_path.pop();
-            lib_path.push("lib");
-
-            let listing_src = ListingSource::from_file_and_path(name, lib_path);
+            let listing_src = ListingSource::User;
 
             load_module(
                 wam,
@@ -608,7 +612,7 @@ fn load_library(
             )
         }
         None => {
-            let err = ExistenceError::SourceSink(ModuleSource::Library(
+            let err = ExistenceError::ModuleSource(ModuleSource::Library(
                 name.clone()
             ));
 
@@ -631,7 +635,7 @@ impl ListingCompiler {
                 .term_dir_entry_len((clause_name!("term_expansion"), 2)),
             orig_goal_expansion_lens: code_repo
                 .term_dir_entry_len((clause_name!("goal_expansion"), 2)),
-	    initialization_goals: (vec![], VecDeque::from(vec![])),
+	        initialization_goals: (vec![], VecDeque::from(vec![])),
             suppress_warnings,
             listing_src
         }
@@ -699,7 +703,7 @@ impl ListingCompiler {
 
             Ok(wam_indices.insert_module(submodule))
         } else {
-            let err = ExistenceError::SourceSink(ModuleSource::File(
+            let err = ExistenceError::ModuleSource(ModuleSource::File(
                 module_name,
             ));
 
@@ -737,7 +741,7 @@ impl ListingCompiler {
 
             Ok(wam_indices.insert_module(submodule))
         } else {
-            let err = ExistenceError::SourceSink(ModuleSource::File(
+            let err = ExistenceError::ModuleSource(ModuleSource::File(
                 module_name
             ));
 
@@ -754,14 +758,14 @@ impl ListingCompiler {
     }
 
     fn generate_init_goal_code(
-	&mut self,
+	    &mut self,
     ) -> Result<Code, SessionError> {
-	let query_terms = mem::replace(&mut self.initialization_goals.0, vec![]);
-	let queue = mem::replace(&mut self.initialization_goals.1, VecDeque::new());
+	    let query_terms = mem::replace(&mut self.initialization_goals.0, vec![]);
+	    let queue = mem::replace(&mut self.initialization_goals.1, VecDeque::new());
 
-	compile_query(query_terms, queue)
-	    .map(|(code, _)| code)
-	    .map_err(SessionError::from)
+	    compile_query(query_terms, queue)
+	        .map(|(code, _)| code)
+	        .map_err(SessionError::from)
     }
 
     fn set_code_index(
@@ -900,7 +904,7 @@ impl ListingCompiler {
                 .or_insert((Predicate::new(), VecDeque::from(vec![])));
 
             len += 1;
-            queue_len += queue_len;
+            queue_len += queue.len();
 
             (preds.0).0.push(clause);
             preds.1.extend(queue.into_iter());
@@ -977,12 +981,12 @@ impl ListingCompiler {
                     Err(SessionError::from(ParserError::InvalidModuleDecl))
                 }
             }
-	    Declaration::ModuleInitialization(query_terms, queue) => {
-		self.initialization_goals.0.extend(query_terms.into_iter());
-		self.initialization_goals.1.extend(queue.into_iter());
+	        Declaration::ModuleInitialization(query_terms, queue) => {
+		        self.initialization_goals.0.extend(query_terms.into_iter());
+		        self.initialization_goals.1.extend(queue.into_iter());
 
-		Ok(())
-	    }
+		        Ok(())
+	        }
             Declaration::MultiFile(..) => {
                 Ok(())
             }
@@ -1071,7 +1075,7 @@ impl ListingCompiler {
                         insert_or_refresh_term_dir_quantum(term_dir, key, term_dirs);
                     }
                     None => {
-                        let err = ExistenceError::SourceSink(ModuleSource::File(
+                        let err = ExistenceError::ModuleSource(ModuleSource::File(
                             module_name,
                         ));
 
@@ -1100,9 +1104,9 @@ impl ListingCompiler {
                     .entry((name.clone(), arity))
                     .or_insert(vec![]);
 
-		indices.code_dir
-		       .entry((name.clone(), arity))
-		       .or_insert(CodeIndex::dynamic_undefined(self.get_module_name()));
+		        indices.code_dir
+		            .entry((name.clone(), arity))
+		            .or_insert(CodeIndex::dynamic_undefined(self.get_module_name()));
             }
             &Declaration::Hook(hook, _, ref queue) if self.module.is_none() => worker
                 .term_stream
@@ -1134,7 +1138,8 @@ impl ListingCompiler {
         result
     }
 
-    pub(crate) fn gather_items(
+    pub(crate)
+    fn gather_items(
         &mut self,
         wam: &mut Machine,
         src: &mut ParsingStream<Stream>,
@@ -1279,6 +1284,17 @@ fn compile_work_impl(
                 .filter(|(name, _)| name.owning_module().as_str() != "builtins")
                 .map(ModuleExport::PredicateKey)
                 .collect();
+
+            module.module_decl.exports.extend(
+                indices.op_dir.iter()
+                    .map(|((name, _), OpDirValue (shared_op_desc, _))|
+                        ModuleExport::OpDecl(OpDecl(
+                            shared_op_desc.prec(),
+                            shared_op_desc.assoc(),
+                            name.clone(),
+                        ))
+                    )
+            );
         }
 
         let mut clause_code_generator =
@@ -1319,7 +1335,7 @@ fn compile_work_impl(
     let init_goal_code = compiler.generate_init_goal_code()?;
 
     if init_goal_code.len() > 0 {
-	if !wam.run_init_code(init_goal_code) {
+	    if !wam.run_init_code(init_goal_code) {
             println!("Warning: initialization goal for {} failed",
                      compiler.listing_src.name());
         }
@@ -1341,7 +1357,8 @@ fn compile_work(
     src: Stream,
     mut indices: IndexStore,
 ) -> EvalSession {
-    let src = &mut parsing_stream(src);
+    let mut stream = try_eval_session!(parsing_stream(src));
+    let src = &mut stream;
     let results = try_eval_session!(compiler.gather_items(wam, src, &mut indices));
 
     try_eval_session!(compile_work_impl(compiler, wam, indices, results));
@@ -1360,9 +1377,9 @@ pub fn compile_special_form(
     let mut indices = default_index_store!(wam.indices.atom_tbl.clone());
     setup_indices(wam, clause_name!("builtins"), &mut indices)?;
 
-    let src = &mut parsing_stream(src);
+    let mut src = parsing_stream(src)?;
     let mut compiler = ListingCompiler::new(&wam.code_repo, true, listing_src);
-    let mut results = compiler.gather_items(wam, src, &mut indices)?;
+    let mut results = compiler.gather_items(wam, &mut src, &mut indices)?;
 
     compiler.adapt_in_situ_code(
         results.worker_results,
@@ -1417,7 +1434,7 @@ pub(super) fn setup_indices(
         wam.indices.insert_module(module);
         result
     } else {
-        let err = ExistenceError::SourceSink(ModuleSource::Library(
+        let err = ExistenceError::ModuleSource(ModuleSource::Library(
             module
         ));
 

src/machine/copier.rs

@@ -1,13 +1,12 @@
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::machine::stack::*;
-use crate::prolog::machine::streams::*;
+use crate::machine::machine_indices::*;
+use crate::machine::stack::*;
 
 use std::mem;
 use std::ops::IndexMut;
 
 type Trail = Vec<(Ref, HeapCellValue)>;
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum AttrVarPolicy {
     DeepCopy,
     StripAttributes
@@ -28,6 +27,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,
@@ -114,14 +114,14 @@ impl<T: CopierTarget> CopyTermState<T> {
         let threshold = self.target.threshold();
 
         *self.value_at_scan() =
-            HeapCellValue::Addr(Addr::PStrLocation(threshold, 0));
+            HeapCellValue::Addr(Addr::PStrLocation(threshold, n));
 
         self.scan += 1;
 
         let (pstr, has_tail) =
             match &self.target[addr] {
                 &HeapCellValue::PartialString(ref pstr, has_tail) => {
-                    (pstr.clone_from_offset(n), has_tail)
+                    (pstr.clone_from_offset(0), has_tail)
                 }
                 _ => {
                     unreachable!()
@@ -130,7 +130,7 @@ impl<T: CopierTarget> CopyTermState<T> {
 
         self.target.push(HeapCellValue::PartialString(pstr, has_tail));
 
-        let replacement = HeapCellValue::Addr(Addr::PStrLocation(threshold, 0));
+        let replacement = HeapCellValue::Addr(Addr::PStrLocation(threshold, n));
 
         let trail_item = mem::replace(
             &mut self.target[addr],
@@ -214,24 +214,6 @@ impl<T: CopierTarget> CopyTermState<T> {
         }
     }
 
-    fn copy_stream(&mut self, addr: usize) {
-        let threshold = self.target.threshold();
-
-        let trail_item = mem::replace(
-            &mut self.target[addr],
-            HeapCellValue::Addr(Addr::Stream(threshold)),
-        );
-
-        self.trail.push((
-            Ref::HeapCell(addr),
-            trail_item,
-        ));
-
-        self.target.push(HeapCellValue::Stream(Stream::null_stream()));
-
-        self.scan += 1;
-    }
-
     fn copy_structure(&mut self, addr: usize) {
         match self.target[addr].context_free_clone() {
             HeapCellValue::NamedStr(arity, name, fixity) => {
@@ -284,11 +266,12 @@ impl<T: CopierTarget> CopyTermState<T> {
                                 *self.value_at_scan() = HeapCellValue::Addr(addr);
                             }
                         }
-                        Addr::Lis(h) if h >= self.old_h => {
-                            self.scan += 1;
-                        }
                         Addr::Lis(h) => {
-                            self.copy_list(h);
+                            if h >= self.old_h {
+                                self.scan += 1;
+                            } else {
+                                self.copy_list(h);
+                            }
                         }
                         addr @ Addr::AttrVar(_) |
                         addr @ Addr::HeapCell(_) |
@@ -302,7 +285,7 @@ impl<T: CopierTarget> CopyTermState<T> {
                             self.copy_partial_string(addr, n);
                         }
                         Addr::Stream(h) => {
-                            self.copy_stream(h);
+                            *self.value_at_scan() = self.target[h].context_free_clone();
                         }
                         _ => {
                             self.scan += 1;

src/machine/dynamic_database.rs

@@ -1,10 +1,10 @@
-use prolog_parser::ast::*;
+use crate::prolog_parser::ast::*;
 
-use crate::prolog::heap_print::*;
-use crate::prolog::machine::*;
-use crate::prolog::machine::compile::*;
-use crate::prolog::machine::machine_errors::*;
-use crate::prolog::machine::streams::*;
+use crate::heap_print::*;
+use crate::machine::*;
+use crate::machine::compile::*;
+use crate::machine::machine_errors::*;
+use crate::machine::streams::*;
 
 use std::convert::TryFrom;
 
@@ -66,6 +66,9 @@ impl Machine {
                     }
                 }
             }
+            Addr::Fixnum(arity) => {
+                usize::try_from(arity).unwrap()
+            }
             Addr::Usize(n) => {
                 n
             }
@@ -98,6 +101,18 @@ impl Machine {
     }
 
     fn make_undefined(&mut self, name: ClauseName, arity: usize) {
+        let module_name = name.owning_module();
+
+        match self.indices.modules.get(&module_name) {
+            Some(ref module) => {
+                if let Some(idx) = module.code_dir.get(&(name.clone(), arity)) {
+                    set_code_index!(idx, IndexPtr::DynamicUndefined, module_name);
+                }
+            }
+            None => {
+            }
+        }
+
         if let Some(idx) = self.indices.code_dir.get(&(name, arity)) {
             set_code_index!(idx, IndexPtr::DynamicUndefined, clause_name!("user"));
         }
@@ -258,7 +273,12 @@ impl Machine {
                         unreachable!()
                     }
                 }
-            _ => unreachable!(),
+            Addr::Fixnum(arity) => {
+                usize::try_from(arity).unwrap()
+            }
+            _ => {
+                unreachable!()
+            }
         };
 
         let (mut name, arity) = self.get_predicate_key(temp_v!(1), temp_v!(2));
@@ -307,6 +327,12 @@ impl Machine {
                     }
                 }
             }
+            Addr::Usize(n) => {
+                n
+            }
+            Addr::Fixnum(n) => {
+                usize::try_from(n).unwrap()
+            }
             _ => {
                 unreachable!()
             }

src/machine/heap.rs

@@ -2,15 +2,16 @@ use core::marker::PhantomData;
 
 use crate::prolog_parser::ast::Constant;
 
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::machine::partial_string::*;
-use crate::prolog::machine::raw_block::*;
+use crate::machine::machine_indices::*;
+use crate::machine::partial_string::*;
+use crate::machine::raw_block::*;
 
 use std::convert::TryFrom;
 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,
@@ -166,21 +171,28 @@ impl<T: RawBlockTraits> HeapTemplate<T> {
             &HeapCellValue::NamedStr(arity, ref name, ref op) => {
                 HeapCellValue::NamedStr(arity, name.clone(), op.clone())
             }
-            &HeapCellValue::Rational(ref r) => {
-                HeapCellValue::Rational(r.clone())
-            }
             &HeapCellValue::PartialString(..) => {
                 HeapCellValue::Addr(Addr::PStrLocation(h, 0))
             }
+            &HeapCellValue::Rational(ref r) => {
+                HeapCellValue::Rational(r.clone())
+            }
             &HeapCellValue::Stream(_) => {
                 HeapCellValue::Addr(Addr::Stream(h))
             }
+            &HeapCellValue::TcpListener(_) => {
+                HeapCellValue::Addr(Addr::TcpListener(h))
+            }
         }
     }
 
     #[inline]
     pub(crate)
     fn put_complete_string(&mut self, s: &str) -> Addr {
+        if s.is_empty() {
+            return Addr::EmptyList;
+        }
+
         let addr = self.allocate_pstr(s);
         self.pop();
 
@@ -208,9 +220,6 @@ impl<T: RawBlockTraits> HeapTemplate<T> {
             Constant::Char(c) => {
                 Addr::Char(c)
             }
-            Constant::CharCode(c) => {
-                Addr::CharCode(c)
-            }
             Constant::EmptyList => {
                 Addr::EmptyList
             }
@@ -280,18 +289,15 @@ impl<T: RawBlockTraits> HeapTemplate<T> {
             HeapCellValue::Addr(addr) => {
                 addr
             }
-            val @ HeapCellValue::Atom(..)
-          | val @ HeapCellValue::Integer(_)
-          | val @ HeapCellValue::DBRef(_)
-          | val @ HeapCellValue::Rational(_) => {
+            val @ HeapCellValue::Atom(..) |
+            val @ HeapCellValue::Integer(_) |
+            val @ HeapCellValue::DBRef(_) |
+            val @ HeapCellValue::Rational(_) => {
                 Addr::Con(self.push(val))
             }
             val @ HeapCellValue::NamedStr(..) => {
                 Addr::Str(self.push(val))
             }
-            val @ HeapCellValue::Stream(..) => {
-                Addr::Stream(self.push(val))
-            }
             HeapCellValue::PartialString(pstr, has_tail) => {
                 let h = self.push(HeapCellValue::PartialString(pstr, has_tail));
 
@@ -301,6 +307,12 @@ impl<T: RawBlockTraits> HeapTemplate<T> {
 
                 Addr::Con(h)
             }
+            val @ HeapCellValue::Stream(..) => {
+                Addr::Stream(self.push(val))
+            }
+            val @ HeapCellValue::TcpListener(..) => {
+                Addr::TcpListener(self.push(val))
+            }
         }
     }
 
@@ -308,20 +320,7 @@ impl<T: RawBlockTraits> HeapTemplate<T> {
     pub(crate)
     fn allocate_pstr(&mut self, src: &str) -> Addr {
         self.write_pstr(src)
-            .unwrap_or_else(|| {
-                let h = self.h();
-
-                self.push(HeapCellValue::PartialString(
-                    PartialString::empty(),
-                    true,
-                ));
-
-                self.push(HeapCellValue::Addr(
-                    Addr::HeapCell(h + 1)
-                ));
-
-                Addr::PStrLocation(h, 0)
-            })
+            .unwrap_or_else(|| Addr::EmptyList)
     }
 
     #[inline]
@@ -512,7 +511,7 @@ impl<T: RawBlockTraits> HeapTemplate<T> {
     pub
     fn index_addr<'a>(&'a self, addr: &Addr) -> RefOrOwned<'a, HeapCellValue> {
         match addr {
-            &Addr::Con(h) | &Addr::Str(h) | &Addr::Stream(h) => {
+            &Addr::Con(h) | &Addr::Str(h) | &Addr::Stream(h) | &Addr::TcpListener(h) => {
                 RefOrOwned::Borrowed(&self[h])
             }
             addr => {

src/machine/machine_errors.rs

@@ -1,28 +1,29 @@
-use prolog_parser::ast::*;
+use crate::prolog_parser::ast::*;
 
-use crate::prolog::forms::{ModuleSource, Number, PredicateKey};
-use crate::prolog::machine::heap::*;
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::machine::machine_state::*;
-use crate::prolog::rug::Integer;
+use crate::forms::{ModuleSource, Number, PredicateKey};
+use crate::machine::heap::*;
+use crate::machine::machine_indices::*;
+use crate::machine::machine_state::*;
+use crate::rug::Integer;
 
 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.
 }
 
-pub(super) struct MachineError {
+#[derive(Debug)]
+pub(crate) struct MachineError {
     stub: MachineStub,
     location: Option<(usize, usize)>, // line_num, col_num
     from: ErrorProvenance,
 }
 
-pub(super)
+pub(crate)
 trait TypeError {
     fn type_error(self, h: usize, valid_type: ValidType) -> MachineError;
 }
@@ -42,6 +43,21 @@ impl TypeError for Addr {
     }
 }
 
+impl TypeError for HeapCellValue {
+    fn type_error(self, _: usize, valid_type: ValidType) -> MachineError {
+        let stub = functor!(
+            "type_error",
+            [atom(valid_type.as_str()), value(self)]
+        );
+
+        MachineError {
+            stub,
+            location: None,
+            from: ErrorProvenance::Received
+        }
+    }
+}
+
 impl TypeError for MachineStub {
     fn type_error(self, h: usize, valid_type: ValidType) -> MachineError {
         let stub = functor!(
@@ -73,7 +89,7 @@ impl TypeError for Number {
     }
 }
 
-pub(super)
+pub(crate)
 trait PermissionError {
     fn permission_error(self, h: usize, index_str: &'static str, perm: Permission) -> MachineError;
 }
@@ -154,6 +170,18 @@ impl MachineError {
         )
     }
 
+    #[inline]
+    pub(super)
+    fn interrupt_error() -> Self {
+        let stub = functor!("$interrupt_thrown");
+
+        MachineError {
+            stub,
+            location: None,
+            from: ErrorProvenance::Received,
+        }
+    }
+
     pub(super)
     fn evaluation_error(eval_error: EvalError) -> Self {
         let stub = functor!("evaluation_error", [atom(eval_error.as_str())]);
@@ -237,7 +265,7 @@ impl MachineError {
                     from: ErrorProvenance::Constructed,
                 }
             }
-            ExistenceError::SourceSink(source) => {
+            ExistenceError::ModuleSource(source) => {
                 let source_stub = source.as_functor_stub();
 
                 let stub = functor!(
@@ -252,6 +280,18 @@ impl MachineError {
                     from: ErrorProvenance::Constructed,
                 }
             }
+            ExistenceError::SourceSink(culprit) => {
+                let stub = functor!(
+                    "existence_error",
+                    [atom("source_sink"), addr(culprit)]
+                );
+
+                MachineError {
+                    stub,
+                    location: None,
+                    from: ErrorProvenance::Received,
+                }
+            }
             ExistenceError::Stream(culprit) => {
                 let stub = functor!(
                     "existence_error",
@@ -435,47 +475,53 @@ impl MachineError {
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum Permission {
     Access,
     Create,
     InputStream,
     Modify,
+    Open,
     OutputStream,
+    Reposition,
 }
 
 impl Permission {
+    #[inline]
     pub fn as_str(self) -> &'static str {
         match self {
             Permission::Access => "access",
             Permission::Create => "create",
             Permission::InputStream => "input",
             Permission::Modify => "modify",
+            Permission::Open => "open",
             Permission::OutputStream => "output",
+            Permission::Reposition => "reposition",
         }
     }
 }
 
 // from 7.12.2 b) of 13211-1:1995
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum ValidType {
     Atom,
     Atomic,
     //    Boolean,
-    //    Byte,
+    Byte,
     Callable,
     Character,
     Compound,
     Evaluable,
     Float,
-    //    InByte,
-    //    InCharacter,
+    InByte,
+    InCharacter,
     Integer,
     List,
-    //    Number,
+    Number,
     Pair,
     //    PredicateIndicator,
     //    Variable
+    TcpListener,
 }
 
 impl ValidType {
@@ -484,27 +530,31 @@ impl ValidType {
             ValidType::Atom => "atom",
             ValidType::Atomic => "atomic",
             //            ValidType::Boolean => "boolean",
-            //            ValidType::Byte => "byte",
+            ValidType::Byte => "byte",
             ValidType::Callable => "callable",
             ValidType::Character => "character",
             ValidType::Compound => "compound",
             ValidType::Evaluable => "evaluable",
             ValidType::Float => "float",
-            //            ValidType::InByte => "in_byte",
-            //            ValidType::InCharacter => "in_character",
+            ValidType::InByte => "in_byte",
+            ValidType::InCharacter => "in_character",
             ValidType::Integer => "integer",
             ValidType::List => "list",
-            //            ValidType::Number => "number",
+            ValidType::Number => "number",
             ValidType::Pair => "pair",
             //            ValidType::PredicateIndicator => "predicate_indicator",
             //            ValidType::Variable => "variable"
+            ValidType::TcpListener => "tcp_listener",
         }
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum DomainErrorType {
+    IOMode,
     NotLessThanZero,
+    Order,
+    SourceSink,
     Stream,
     StreamOrAlias,
 }
@@ -512,7 +562,10 @@ pub enum DomainErrorType {
 impl DomainErrorType {
     pub fn as_str(self) -> &'static str {
         match self {
+            DomainErrorType::IOMode => "io_mode",
             DomainErrorType::NotLessThanZero => "not_less_than_zero",
+            DomainErrorType::Order => "order",
+            DomainErrorType::SourceSink => "source_sink",
             DomainErrorType::Stream => "stream",
             DomainErrorType::StreamOrAlias => "stream_or_alias",
         }
@@ -520,11 +573,11 @@ impl DomainErrorType {
 }
 
 // from 7.12.2 f) of 13211-1:1995
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum RepFlag {
     Character,
     CharacterCode,
-    //    InCharacterCode,
+    InCharacterCode,
     MaxArity,
     //    MaxInteger,
     //    MinInteger
@@ -535,7 +588,7 @@ impl RepFlag {
         match self {
             RepFlag::Character => "character",
             RepFlag::CharacterCode => "character_code",
-            //            RepFlag::InCharacterCode => "in_character_code",
+            RepFlag::InCharacterCode => "in_character_code",
             RepFlag::MaxArity => "max_arity",
             //            RepFlag::MaxInteger => "max_integer",
             //            RepFlag::MinInteger => "min_integer"
@@ -544,7 +597,7 @@ impl RepFlag {
 }
 
 // from 7.12.2 g) of 13211-1:1995
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum EvalError {
     FloatOverflow,
     Undefined,
@@ -564,7 +617,7 @@ impl EvalError {
 }
 
 // used by '$skip_max_list'.
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub(super) enum CycleSearchResult {
     EmptyList,
     NotList,
@@ -666,6 +719,41 @@ impl MachineState {
         self.check_for_list_pairs(sorted)
     }
 
+    #[inline]
+    pub(crate)
+    fn type_error<T: TypeError>(
+        &self,
+        valid_type: ValidType,
+        culprit: T,
+        caller: ClauseName,
+        arity: usize,
+    ) -> MachineStub {
+        let stub = MachineError::functor_stub(caller, arity);
+        let err = MachineError::type_error(
+            self.heap.h(),
+            valid_type,
+            culprit,
+        );
+
+        return self.error_form(err, stub);
+    }
+
+    #[inline]
+    pub(crate)
+    fn representation_error(
+        &self,
+        rep_flag: RepFlag,
+        caller: ClauseName,
+        arity: usize,
+    ) -> MachineStub {
+        let stub = MachineError::functor_stub(caller, arity);
+        let err = MachineError::representation_error(
+            rep_flag,
+        );
+
+        return self.error_form(err, stub);
+    }
+
     pub(super)
     fn error_form(&self, err: MachineError, src: MachineStub) -> MachineStub {
         let location = err.location;
@@ -708,13 +796,16 @@ impl MachineState {
     }
 }
 
+#[derive(Debug)]
 pub enum ExistenceError {
     Module(ClauseName),
+    ModuleSource(ModuleSource),
     Procedure(ClauseName, usize),
-    SourceSink(ModuleSource),
+    SourceSink(Addr),
     Stream(Addr),
 }
 
+#[derive(Debug)]
 pub enum SessionError {
     CannotOverwriteBuiltIn(ClauseName),
     CannotOverwriteImport(ClauseName),
@@ -727,6 +818,7 @@ pub enum SessionError {
     ParserError(ParserError),
 }
 
+#[derive(Debug)]
 pub enum EvalSession {
     EntrySuccess,
     Error(SessionError),
@@ -748,5 +840,4 @@ impl From<ParserError> for EvalSession {
     fn from(err: ParserError) -> Self {
         EvalSession::from(SessionError::ParserError(err))
     }
-
 }

src/machine/machine_indices.rs

@@ -1,36 +1,38 @@
-use prolog_parser::ast::*;
-use prolog_parser::tabled_rc::*;
+use crate::prolog_parser::ast::*;
+use crate::prolog_parser::tabled_rc::*;
 
-use crate::prolog::clause_types::*;
-use crate::prolog::fixtures::*;
-use crate::prolog::forms::*;
-use crate::prolog::machine::code_repo::CodeRepo;
-use crate::prolog::machine::Ball;
-use crate::prolog::machine::heap::*;
-use crate::prolog::machine::machine_state::*;
-use crate::prolog::machine::partial_string::*;
-use crate::prolog::machine::raw_block::RawBlockTraits;
-use crate::prolog::machine::streams::Stream;
-use crate::prolog::instructions::*;
-use crate::prolog::ordered_float::OrderedFloat;
-use crate::prolog::rug::{Integer, Rational};
+use crate::clause_types::*;
+use crate::fixtures::*;
+use crate::forms::*;
+use crate::machine::code_repo::CodeRepo;
+use crate::machine::Ball;
+use crate::machine::heap::*;
+use crate::machine::machine_state::*;
+use crate::machine::partial_string::*;
+use crate::machine::raw_block::RawBlockTraits;
+use crate::machine::streams::Stream;
+use crate::instructions::*;
+use crate::ordered_float::OrderedFloat;
+use crate::rug::{Integer, Rational};
 
-use indexmap::IndexMap;
+use crate::indexmap::IndexMap;
 
 use std::cell::RefCell;
 use std::cmp::Ordering;
-use std::collections::{BTreeMap, VecDeque};
+use std::collections::{BTreeMap, BTreeSet, VecDeque};
 use std::convert::TryFrom;
+use std::fmt;
 use std::mem;
+use std::net::TcpListener;
 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 +45,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,11 +54,10 @@ pub enum TermOrderCategory {
     Compound,
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum Addr {
     AttrVar(usize),
     Char(char),
-    CharCode(u32),
     Con(usize),
     CutPoint(usize),
     EmptyList,
@@ -68,10 +69,11 @@ pub enum Addr {
     StackCell(usize, usize),
     Str(usize),
     Stream(usize),
+    TcpListener(usize),
     Usize(usize),
 }
 
-#[derive(Clone, Copy, Hash, Eq, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq, PartialOrd)]
 pub enum Ref {
     AttrVar(usize),
     HeapCell(usize),
@@ -116,7 +118,7 @@ impl PartialEq<Ref> for Addr {
     }
 }
 
-// for use in MachineState::bind.
+// for use crate::in MachineState::bind.
 impl PartialOrd<Ref> for Addr {
     fn partial_cmp(&self, r: &Ref) -> Option<Ordering> {
         match self {
@@ -157,7 +159,7 @@ impl Addr {
     #[inline]
     pub fn is_heap_bound(&self) -> bool {
         match self {
-            Addr::Char(_) | Addr::CharCode(_) | Addr::EmptyList |
+            Addr::Char(_) | Addr::EmptyList |
             Addr::CutPoint(_) | Addr::Usize(_) | Addr::Fixnum(_) |
             Addr::Float(_) => {
                 false
@@ -223,13 +225,13 @@ impl Addr {
                     Addr::Char(_) | Addr::EmptyList => {
                         Some(TermOrderCategory::Atom)
                     }
-                    Addr::CharCode(_) | Addr::Fixnum(_) | Addr::Usize(_) => {
+                    Addr::Fixnum(_) | Addr::Usize(_) => {
                         Some(TermOrderCategory::Integer)
                     }
                     Addr::Lis(_) | Addr::PStrLocation(..) | Addr::Str(_) => {
                         Some(TermOrderCategory::Compound)
                     }
-                    Addr::CutPoint(_) | Addr::Stream(_) => {
+                    Addr::CutPoint(_) | Addr::Stream(_) | Addr::TcpListener(_) => {
                         None
                     }
                 }
@@ -237,18 +239,18 @@ impl Addr {
         }
     }
 
-    pub fn as_constant(&self, machine_st: &MachineState) -> Option<Constant> {
+    pub fn as_constant_index(&self, machine_st: &MachineState) -> Option<Constant> {
         match self {
             &Addr::Char(c) => {
                 Some(Constant::Char(c))
             }
-            &Addr::CharCode(c) => {
-                Some(Constant::CharCode(c))
-            }
             &Addr::Con(h) => {
                 match &machine_st.heap[h] {
-                    &HeapCellValue::Atom(ref name, ref op) => {
-                        Some(Constant::Atom(name.clone(), op.clone()))
+                    &HeapCellValue::Atom(ref name, _) if name.is_char() => {
+                        Some(Constant::Char(name.as_str().chars().next().unwrap()))
+                    }
+                    &HeapCellValue::Atom(ref name, _) => {
+                        Some(Constant::Atom(name.clone(), None))
                     }
                     &HeapCellValue::Integer(ref n) => {
                         Some(Constant::Integer(n.clone()))
@@ -270,18 +272,8 @@ impl Addr {
             &Addr::Float(f) => {
                 Some(Constant::Float(f))
             }
-            &Addr::PStrLocation(h, n) => {
-                let mut heap_pstr_iter =
-                    machine_st.heap_pstr_iter(Addr::PStrLocation(h, n));
-
-                let buf = heap_pstr_iter.to_string();
-                let end_addr = heap_pstr_iter.focus();
-
-                if end_addr == Addr::EmptyList {
-                    Some(Constant::String(Rc::new(buf)))
-                } else {
-                    None
-                }
+            &Addr::Usize(n) => {
+                Some(Constant::Usize(n))
             }
             _ => {
                 None
@@ -358,7 +350,7 @@ impl SubAssign<usize> for Addr {
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum TrailRef {
     Ref(Ref),
     AttrVarHeapLink(usize),
@@ -371,6 +363,7 @@ impl From<Ref> for TrailRef {
     }
 }
 
+#[derive(Debug)]
 pub enum HeapCellValue {
     Addr(Addr),
     Atom(ClauseName, Option<SharedOpDesc>),
@@ -380,6 +373,7 @@ pub enum HeapCellValue {
     Rational(Rc<Rational>),
     PartialString(PartialString, bool), // the partial string, a bool indicating whether it came from a Constant.
     Stream(Stream),
+    TcpListener(TcpListener),
 }
 
 impl HeapCellValue {
@@ -402,6 +396,9 @@ impl HeapCellValue {
             HeapCellValue::Stream(_) => {
                 Addr::Stream(focus)
             }
+            HeapCellValue::TcpListener(_) => {
+                Addr::TcpListener(focus)
+            }
         }
     }
 
@@ -429,8 +426,11 @@ impl HeapCellValue {
             &HeapCellValue::PartialString(ref pstr, has_tail) => {
                 HeapCellValue::PartialString(pstr.clone(), has_tail)
             }
-            &HeapCellValue::Stream(_) => {
-                HeapCellValue::Stream(Stream::null_stream())
+            &HeapCellValue::Stream(ref stream) => {
+                HeapCellValue::Stream(stream.clone())
+            }
+            &HeapCellValue::TcpListener(_) => {
+                HeapCellValue::Atom(clause_name!("$tcp_listener"), None)
             }
         }
     }
@@ -443,7 +443,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,
@@ -453,7 +453,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 {
@@ -508,7 +508,7 @@ impl From<(usize, ClauseName)> for CodeIndex {
     }
 }
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum DynamicAssertPlace {
     Back,
     Front,
@@ -532,7 +532,7 @@ impl DynamicAssertPlace {
     }
 }
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum DynamicTransactionType {
     Abolish,
     Assert(DynamicAssertPlace),
@@ -542,7 +542,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,
@@ -551,7 +551,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.
@@ -770,7 +770,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.
 }
@@ -790,6 +790,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,
@@ -806,7 +807,9 @@ impl ModuleStub {
 
 pub(crate) type ModuleStubDir = IndexMap<ClauseName, ModuleStub>;
 pub(crate) type StreamAliasDir = IndexMap<ClauseName, Stream>;
+pub(crate) type StreamDir = BTreeSet<Stream>;
 
+#[derive(Debug)]
 pub struct IndexStore {
     pub(super) atom_tbl: TabledData<Atom>,
     pub(super) code_dir: CodeDir,
@@ -817,6 +820,7 @@ pub struct IndexStore {
     pub(super) module_dir: ModuleDir,
     pub(super) modules: ModuleDir,
     pub(super) op_dir: OpDir,
+    pub(super) streams: StreamDir,
     pub(super) stream_aliases: StreamAliasDir,
 }
 
@@ -905,6 +909,7 @@ impl IndexStore {
             op_dir: default_op_dir(),
             modules: ModuleDir::new(),
             stream_aliases: StreamAliasDir::new(),
+            streams: StreamDir::new(),
         }
     }
 
@@ -957,6 +962,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>),
@@ -985,6 +991,7 @@ impl TermDirQuantumEntry {
     }
 }
 
+#[derive(Debug)]
 pub struct TermDirQuantum(IndexMap<PredicateKey, TermDirQuantumEntry>);
 
 impl TermDirQuantum {
@@ -1028,7 +1035,7 @@ impl TermDirQuantum {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Ord, PartialOrd)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd)]
 pub enum CompileTimeHook {
     GoalExpansion,
     TermExpansion,
@@ -1082,6 +1089,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/machine/machine_state.rs

@@ -1,30 +1,31 @@
-use prolog_parser::ast::*;
-use prolog_parser::tabled_rc::*;
+use crate::prolog_parser::ast::*;
+use crate::prolog_parser::tabled_rc::*;
 
-use crate::prolog::clause_types::*;
-use crate::prolog::forms::*;
-use crate::prolog::heap_print::*;
-use crate::prolog::machine::attributed_variables::*;
-use crate::prolog::machine::copier::*;
-use crate::prolog::machine::heap::*;
-use crate::prolog::machine::machine_errors::*;
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::machine::modules::*;
-use crate::prolog::machine::stack::*;
-use crate::prolog::machine::streams::*;
-use crate::prolog::read::readline;
-use crate::prolog::rug::Integer;
+use crate::clause_types::*;
+use crate::forms::*;
+use crate::heap_print::*;
+use crate::machine::attributed_variables::*;
+use crate::machine::copier::*;
+use crate::machine::heap::*;
+use crate::machine::machine_errors::*;
+use crate::machine::machine_indices::*;
+use crate::machine::modules::*;
+use crate::machine::stack::*;
+use crate::machine::streams::*;
+use crate::rug::Integer;
 
-use downcast::Any;
+use crate::downcast::Any;
 
-use indexmap::{IndexMap, IndexSet};
+use crate::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,
@@ -43,7 +44,7 @@ impl<'a> HeapPStrIter<'a> {
 
     #[inline]
     pub(crate)
-    fn focus(&'a self) -> Addr {
+    fn focus(&self) -> Addr {
         self.machine_st.store(self.machine_st.deref(self.focus))
     }
 
@@ -74,7 +75,7 @@ impl<'a> HeapPStrIter<'a> {
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub(crate) enum PStrIteratee {
     Char(char),
     PStrSegment(usize, usize),
@@ -147,6 +148,116 @@ impl<'a> Iterator for HeapPStrIter<'a> {
     }
 }
 
+#[inline]
+pub(super)
+fn compare_pstr_prefixes<'a>(
+    i1: &mut HeapPStrIter<'a>,
+    i2: &mut HeapPStrIter<'a>,
+) -> Option<Ordering> {
+    let mut r1 = i1.next();
+    let mut r2 = i2.next();
+
+    loop {
+        if let Some(r1i) = r1 {
+            if let Some(r2i) = r2 {
+                match (r1i, r2i) {
+                    (PStrIteratee::Char(c1), PStrIteratee::Char(c2)) => {
+                        if c1 != c2 {
+                            return c1.partial_cmp(&c2);
+                        }
+                    }
+                    (PStrIteratee::Char(c1), PStrIteratee::PStrSegment(h, n)) => {
+                        if let &HeapCellValue::PartialString(ref pstr, _) = &i2.machine_st.heap[h] {
+                            if let Some(c2) = pstr.as_str_from(n).chars().next() {
+                                if c1 != c2 {
+                                    return c1.partial_cmp(&c2);
+                                } else {
+                                    r1 = i1.next();
+                                    r2 = Some(PStrIteratee::PStrSegment(h, n + c2.len_utf8()));
+
+                                    continue;
+                                }
+                            } else {
+                                r2 = i2.next();
+                                continue;
+                            }
+                        } else {
+                            unreachable!()
+                        }
+                    }
+                    (PStrIteratee::PStrSegment(h, n), PStrIteratee::Char(c2)) => {
+                        if let &HeapCellValue::PartialString(ref pstr, _) = &i1.machine_st.heap[h] {
+                            if let Some(c1) = pstr.as_str_from(n).chars().next() {
+                                if c1 != c2 {
+                                    return c2.partial_cmp(&c1);
+                                } else {
+                                    r1 = i1.next();
+                                    r2 = Some(PStrIteratee::PStrSegment(h, n + c1.len_utf8()));
+
+                                    continue;
+                                }
+                            } else {
+                                r1 = i1.next();
+                                continue;
+                            }
+                        } else {
+                            unreachable!()
+                        }
+                    }
+                    (PStrIteratee::PStrSegment(h1, n1), PStrIteratee::PStrSegment(h2, n2)) => {
+                        match (&i1.machine_st.heap[h1], &i2.machine_st.heap[h2]) {
+                            (
+                                &HeapCellValue::PartialString(ref pstr1, _),
+                                &HeapCellValue::PartialString(ref pstr2, _),
+                            ) => {
+                                let str1 = pstr1.as_str_from(n1);
+                                let str2 = pstr2.as_str_from(n2);
+
+                                if str1.starts_with(str2) {
+                                    r1 = Some(PStrIteratee::PStrSegment(h1, n1 + str2.len()));
+                                    r2 = i2.next();
+
+                                    continue;
+                                } else if str2.starts_with(str1) {
+                                    r1 = i1.next();
+                                    r2 = Some(PStrIteratee::PStrSegment(h2, n2 + str1.len()));
+
+                                    continue;
+                                } else {
+                                    return str1.partial_cmp(str2);
+                                }
+                            }
+                            _ => {
+                                unreachable!()
+                            }
+                        }
+                    }
+                }
+
+                r1 = i1.next();
+                r2 = i2.next();
+
+                continue;
+            }
+        }
+
+        return match (i1.focus(), i2.focus()) {
+            (Addr::EmptyList, Addr::EmptyList) => {
+                Some(Ordering::Equal)
+            }
+            (Addr::EmptyList, _) => {
+                Some(Ordering::Less)
+            }
+            (_, Addr::EmptyList) => {
+                Some(Ordering::Greater)
+            }
+            _ => {
+                None
+            }
+        };
+    }
+}
+
 #[inline]
 pub(super)
 fn compare_pstr_to_string<'a>(
@@ -165,7 +276,7 @@ fn compare_pstr_to_string<'a>(
                         s_offset += c1.len_utf8();
                     }
                 } else {
-                    return None;
+                    return Some(s_offset);
                 }
             }
             PStrIteratee::PStrSegment(h, n) => {
@@ -191,11 +302,16 @@ fn compare_pstr_to_string<'a>(
                 }
             }
         }
+
+        if s[s_offset ..].is_empty() {
+            return Some(s_offset);
+        }
     }
 
     Some(s_offset)
 }
 
+#[derive(Debug)]
 pub struct Ball {
     pub(super) boundary: usize,
     pub(super) stub: Heap,
@@ -247,6 +363,7 @@ impl Ball {
     }
 }
 
+#[derive(Debug)]
 pub(super) struct CopyTerm<'a> {
     state: &'a mut MachineState,
 }
@@ -294,6 +411,7 @@ impl<'a> CopierTarget for CopyTerm<'a> {
     }
 }
 
+#[derive(Debug)]
 pub(super) struct CopyBallTerm<'a> {
     stack: &'a mut Stack,
     heap: &'a mut Heap,
@@ -419,13 +537,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),
@@ -466,6 +584,7 @@ impl Default for HeapPtr {
     }
 }
 
+#[derive(Debug)]
 pub struct MachineState {
     pub(super) s: HeapPtr,
     pub(super) p: CodePtr,
@@ -497,56 +616,130 @@ impl MachineState {
     pub(crate)
     fn read_term(
         &mut self,
-        current_input_stream: &mut Stream,
+        mut stream: Stream,
         indices: &mut IndexStore,
     ) -> CallResult {
-        match self.read(
-            &mut parsing_stream(current_input_stream.clone()),
-            indices.atom_tbl.clone(),
-            &indices.op_dir,
-        ) {
-            Ok(term_write_result) => {
-                let a1 = self[temp_v!(1)];
-                self.unify(Addr::HeapCell(term_write_result.heap_loc), a1);
+        self.check_stream_properties(
+            &mut stream,
+            StreamType::Text,
+            Some(self[temp_v!(2)]),
+            clause_name!("read_term"),
+            3,
+        )?;
 
-                if self.fail {
-                    return Ok(());
-                }
-
-                let mut list_of_var_eqs = vec![];
-
-                for (var, binding) in term_write_result.var_dict.into_iter().rev() {
-                    let var_atom = clause_name!(var.to_string(), indices.atom_tbl);
-
-                    let h = self.heap.h();
-                    let spec = fetch_atom_op_spec(clause_name!("="), None, &indices.op_dir);
-
-                    self.heap.push(HeapCellValue::NamedStr(2, clause_name!("="), spec));
-                    self.heap.push(HeapCellValue::Atom(var_atom, None));
-                    self.heap.push(HeapCellValue::Addr(binding));
-
-                    list_of_var_eqs.push(Addr::Str(h));
-                }
-
-                let a2 = self[temp_v!(2)];
-                let list_offset =
-                    Addr::HeapCell(self.heap.to_list(list_of_var_eqs.into_iter()));
-
-                Ok(self.unify(list_offset, a2))
+        if stream.past_end_of_stream() {
+            if EOFAction::Reset != stream.options.eof_action {
+                return return_from_clause!(self.last_call, self);
+            } else if self.fail {
+                return Ok(());
             }
-            Err(err) => {
-                if let ParserError::UnexpectedEOF = err {
-                    std::process::exit(0);
+        }
+
+        let mut orig_stream = stream.clone();
+
+        loop {
+            match self.read(
+                stream.clone(),
+                indices.atom_tbl.clone(),
+                &indices.op_dir,
+            ) {
+                Ok(term_write_result) => {
+                    let term = self[temp_v!(2)];
+                    self.unify(Addr::HeapCell(term_write_result.heap_loc), term);
+
+                    if self.fail {
+                        return Ok(());
+                    }
+
+                    let mut list_of_var_eqs = vec![];
+
+                    for (var, binding) in term_write_result.var_dict.into_iter() {
+                        let var_atom = clause_name!(var.to_string(), indices.atom_tbl);
+
+                        let h = self.heap.h();
+                        let spec = fetch_atom_op_spec(clause_name!("="), None, &indices.op_dir);
+
+                        self.heap.push(HeapCellValue::NamedStr(2, clause_name!("="), spec));
+                        self.heap.push(HeapCellValue::Atom(var_atom, None));
+                        self.heap.push(HeapCellValue::Addr(binding));
+
+                        list_of_var_eqs.push(Addr::Str(h));
+                    }
+
+                    let mut var_set: IndexMap<Ref, bool> = IndexMap::new();
+
+                    for addr in self.acyclic_pre_order_iter(term) {
+                        if let Some(var) = addr.as_var() {
+                            if !var_set.contains_key(&var) {
+                                var_set.insert(var, true);
+                            } else {
+                                var_set.insert(var, false);
+                            }
+                        }
+                    }
+
+                    let mut var_list = vec![];
+                    let mut singleton_var_list = vec![];
+
+                    for addr in self.acyclic_pre_order_iter(term) {
+                        if let Some(var) = addr.as_var() {
+                            if var_set.get(&var) == Some(&true) {
+                                singleton_var_list.push(var.as_addr());
+                            }
+
+                            var_list.push(var.as_addr());
+                        }
+                    }
+
+                    let singleton_addr = self[temp_v!(3)];
+                    let singletons_offset =
+                        Addr::HeapCell(self.heap.to_list(singleton_var_list.into_iter()));
+
+                    self.unify(singletons_offset, singleton_addr);
+
+                    if self.fail {
+                        return Ok(());
+                    }
+
+                    let vars_addr = self[temp_v!(4)];
+                    let vars_offset =
+                        Addr::HeapCell(self.heap.to_list(var_list.into_iter()));
+
+                    self.unify(vars_offset, vars_addr);
+
+                    if self.fail {
+                        return Ok(());
+                    }
+
+                    let var_names_addr = self[temp_v!(5)];
+                    let var_names_offset =
+                        Addr::HeapCell(self.heap.to_list(list_of_var_eqs.into_iter()));
+
+                    return Ok(self.unify(var_names_offset, var_names_addr));
                 }
+                Err(err) => {
+                    if let ParserError::UnexpectedEOF = err {
+                        self.eof_action(
+                            self[temp_v!(2)],
+                            &mut orig_stream,
+                            clause_name!("read_term"),
+                            3
+                        )?;
 
-                // reset the input stream after an input failure.
-                *current_input_stream = readline::input_stream();
+                        if orig_stream.options.eof_action == EOFAction::Reset {
+                            if self.fail == false {
+                                continue;
+                            }
+                        }
 
-                let h = self.heap.h();
-                let syntax_error = MachineError::syntax_error(h, err);
-                let stub = MachineError::functor_stub(clause_name!("read_term"), 2);
+                        return Ok(());
+                    }
 
-                Err(self.error_form(syntax_error, stub))
+                    let stub = MachineError::functor_stub(clause_name!("read_term"), 3);
+                    let err = MachineError::syntax_error(self.heap.h(), err);
+
+                    return Err(self.error_form(err, stub));
+                }
             }
         }
     }
@@ -557,10 +750,10 @@ impl MachineState {
         op_dir: &'a OpDir,
     ) -> Result<Option<HCPrinter<'a, PrinterOutputter>>, MachineStub>
     {
-        let ignore_ops = self.store(self.deref(self[temp_v!(2)]));
-        let numbervars = self.store(self.deref(self[temp_v!(3)]));
-        let quoted = self.store(self.deref(self[temp_v!(4)]));
-        let max_depth = self.store(self.deref(self[temp_v!(6)]));
+        let ignore_ops = self.store(self.deref(self[temp_v!(3)]));
+        let numbervars = self.store(self.deref(self[temp_v!(4)]));
+        let quoted = self.store(self.deref(self[temp_v!(5)]));
+        let max_depth = self.store(self.deref(self[temp_v!(7)]));
 
         let mut printer = HCPrinter::new(&self, op_dir, PrinterOutputter::new());
 
@@ -610,7 +803,7 @@ impl MachineState {
 
         let stub = MachineError::functor_stub(clause_name!("write_term"), 2);
 
-        match self.try_from_list(temp_v!(5), stub) {
+        match self.try_from_list(temp_v!(6), stub) {
             Ok(addrs) => {
                 let mut var_names: IndexMap<Addr, String> = IndexMap::new();
 
@@ -643,9 +836,11 @@ impl MachineState {
 
                                 var_names.insert(var, atom);
                             }
-                            _ => unreachable!(),
+                            _ => {
+                            }
                         },
-                        _ => unreachable!(),
+                        _ => {
+                        }
                     }
                 }
 
@@ -824,7 +1019,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;
@@ -1076,10 +1271,38 @@ pub(crate) trait CallPolicy: Any {
                 return_from_clause!(machine_st.last_call, machine_st)
             }
             &BuiltInClauseType::Compare => {
-                let a1 = machine_st[temp_v!(1)];
+                let a1 = machine_st.store(machine_st.deref(machine_st[temp_v!(1)]));
                 let a2 = machine_st[temp_v!(2)];
                 let a3 = machine_st[temp_v!(3)];
 
+                match a1 {
+                    Addr::Con(h) if machine_st.heap.atom_at(h) => {
+                        if let HeapCellValue::Atom(ref atom, _) = &machine_st.heap[h] {
+                            match atom.as_str() {
+                                ">" | "<" | "=" => {
+                                }
+                                _ => {
+                                    let stub =
+                                        MachineError::functor_stub(clause_name!("compare"), 3);
+
+                                    let err = MachineError::domain_error(DomainErrorType::Order, a1);
+                                    return Err(machine_st.error_form(err, stub));
+                                }
+                            }
+                        } else {
+                            unreachable!()
+                        }
+                    }
+                    addr if !addr.is_ref() => {
+                        let h = machine_st.heap.h();
+                        let stub = MachineError::functor_stub(clause_name!("compare"), 3);
+                        let err = MachineError::type_error(h, ValidType::Atom, a1);
+                        return Err(machine_st.error_form(err, stub));
+                    }
+                    _ => {
+                    }
+                }
+
                 let atom = match machine_st.compare_term_test(&a2, &a3) {
                     Some(Ordering::Greater) => {
                         let spec = fetch_atom_op_spec(clause_name!(">"), None, &indices.op_dir);
@@ -1114,7 +1337,7 @@ pub(crate) trait CallPolicy: Any {
             }
             &BuiltInClauseType::Read => {
                 match machine_st.read(
-                    &mut parsing_stream(current_input_stream.clone()),
+                    current_input_stream.clone(),
                     indices.atom_tbl.clone(),
                     &indices.op_dir,
                 ) {
@@ -1122,6 +1345,15 @@ pub(crate) trait CallPolicy: Any {
                         let addr = machine_st[temp_v!(1)];
                         machine_st.unify(addr, Addr::HeapCell(offset.heap_loc));
                     }
+                    Err(ParserError::UnexpectedEOF) => {
+                        let addr = machine_st[temp_v!(1)];
+                        let eof = clause_name!("end_of_file".to_string(),
+                            indices.atom_tbl);
+                        let atom = machine_st.heap.to_unifiable(
+                            HeapCellValue::Atom(eof, None)
+                        );
+                        machine_st.unify(addr, atom);
+                    }
                     Err(e) => {
                         let h = machine_st.heap.h();
                         let stub = MachineError::functor_stub(clause_name!("read"), 1);
@@ -1379,10 +1611,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,
@@ -1463,7 +1697,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;
 }
@@ -1489,6 +1723,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) {
@@ -1503,6 +1738,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/machine/machine_state_impl.rs

@@ -1,24 +1,24 @@
-use prolog_parser::ast::*;
-use prolog_parser::tabled_rc::*;
+use crate::prolog_parser::ast::*;
+use crate::prolog_parser::tabled_rc::*;
 
-use crate::prolog::clause_types::*;
-use crate::prolog::forms::*;
-use crate::prolog::heap_iter::*;
-use crate::prolog::instructions::*;
-use crate::prolog::machine::INTERRUPT;
-use crate::prolog::machine::attributed_variables::*;
-use crate::prolog::machine::code_repo::CodeRepo;
-use crate::prolog::machine::copier::*;
-use crate::prolog::machine::heap::*;
-use crate::prolog::machine::machine_errors::*;
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::machine::machine_state::*;
-use crate::prolog::machine::stack::*;
-use crate::prolog::machine::streams::*;
-use crate::prolog::ordered_float::*;
-use crate::prolog::rug::Integer;
+use crate::clause_types::*;
+use crate::forms::*;
+use crate::heap_iter::*;
+use crate::instructions::*;
+use crate::machine::INTERRUPT;
+use crate::machine::attributed_variables::*;
+use crate::machine::code_repo::CodeRepo;
+use crate::machine::copier::*;
+use crate::machine::heap::*;
+use crate::machine::machine_errors::*;
+use crate::machine::machine_indices::*;
+use crate::machine::machine_state::*;
+use crate::machine::stack::*;
+use crate::machine::streams::*;
+use crate::ordered_float::*;
+use crate::rug::Integer;
 
-use indexmap::{IndexMap, IndexSet};
+use crate::indexmap::{IndexMap, IndexSet};
 
 use std::cmp::Ordering;
 use std::convert::TryFrom;
@@ -281,19 +281,18 @@ impl MachineState {
                     (Addr::PStrLocation(h1, n1), Addr::PStrLocation(h2, n2)) => {
                         if let &HeapCellValue::PartialString(ref pstr1, has_tail_1) = &self.heap[h1] {
                             if let &HeapCellValue::PartialString(ref pstr2, has_tail_2) = &self.heap[h2] {
-                                let pstr1_iter = pstr1.range_from(n1 ..);
-                                let pstr2_iter = pstr2.range_from(n2 ..);
+                                let pstr1_s = pstr1.as_str_from(n1);
+                                let pstr2_s = pstr2.as_str_from(n2);
 
-                                let mut m_len = 0;
-
-                                for (c1, c2) in pstr1_iter.zip(pstr2_iter) {
-                                    if c1 != c2 {
+                                let m_len =
+                                    if pstr1_s.starts_with(pstr2_s) {
+                                        pstr2_s.len()
+                                    } else if pstr2_s.starts_with(pstr1_s) {
+                                        pstr1_s.len()
+                                    } else {
                                         self.fail = true;
                                         return;
-                                    }
-
-                                    m_len += c1.len_utf8();
-                                }
+                                    };
 
                                 if pstr1.at_end(n1 + m_len) {
                                     if has_tail_1 {
@@ -499,19 +498,18 @@ impl MachineState {
                     (Addr::PStrLocation(h1, n1), Addr::PStrLocation(h2, n2)) => {
                         if let &HeapCellValue::PartialString(ref pstr1, has_tail_1) = &self.heap[h1] {
                             if let &HeapCellValue::PartialString(ref pstr2, has_tail_2) = &self.heap[h2] {
-                                let pstr1_iter = pstr1.range_from(n1 ..);
-                                let pstr2_iter = pstr2.range_from(n2 ..);
+                                let pstr1_s = pstr1.as_str_from(n1);
+                                let pstr2_s = pstr2.as_str_from(n2);
 
-                                let mut m_len = 0;
-
-                                for (c1, c2) in pstr1_iter.zip(pstr2_iter) {
-                                    if c1 != c2 {
+                                let m_len =
+                                    if pstr1_s.starts_with(pstr2_s) {
+                                        pstr2_s.len()
+                                    } else if pstr2_s.starts_with(pstr1_s) {
+                                        pstr1_s.len()
+                                    } else {
                                         self.fail = true;
                                         return;
-                                    }
-
-                                    m_len += c1.len_utf8();
-                                }
+                                    };
 
                                 if pstr1.at_end(n1 + m_len) {
                                     if has_tail_1 {
@@ -691,7 +689,7 @@ impl MachineState {
             &mut HeapPtr::PStrChar(h, ref mut n) |
             &mut HeapPtr::PStrLocation(h, ref mut n) => {
                 match &self.heap[h] {
-                    HeapCellValue::PartialString(ref pstr, _) => {
+                    &HeapCellValue::PartialString(ref pstr, _) => {
                         for c in pstr.range_from(*n ..).take(rhs) {
                             *n += c.len_utf8();
                         }
@@ -699,7 +697,6 @@ impl MachineState {
                         self.s = HeapPtr::PStrLocation(h, *n);
                     }
                     _ => {
-                        unreachable!()
                     }
                 }
             }
@@ -798,7 +795,7 @@ impl MachineState {
                             if let Some(var) = addr.as_var() {
                                 self.bind(var, Addr::EmptyList);
                             } else {
-                                self.fail = true;
+                                self.fail = addr != Addr::EmptyList;
                             }
                         }
                     }
@@ -806,9 +803,7 @@ impl MachineState {
             }
             Some(prefix_len) => {
                 match heap_pstr_iter.focus() {
-                    addr @ Addr::AttrVar(_) |
-                    addr @ Addr::StackCell(..) |
-                    addr @ Addr::HeapCell(_) => {
+                    addr if addr.is_ref() => {
                         let h = self.heap.h();
 
                         let pstr_addr =
@@ -823,7 +818,7 @@ impl MachineState {
 
                         self.bind(addr.as_var().unwrap(), pstr_addr);
                     }
-                    Addr::Lis(l) if !self.flags.double_quotes.is_atom() => {
+                    Addr::Lis(l) => {
                         let h = self.heap.h();
 
                         let pstr_addr =
@@ -925,7 +920,7 @@ impl MachineState {
                     self.fail = true;
                 }
             }
-            Addr::Lis(l) if !self.flags.double_quotes.is_atom() => {
+            Addr::Lis(l) => {
                 let addr = self.heap.put_constant(c.clone());
                 self.unify(Addr::Lis(l), addr);
             }
@@ -957,7 +952,7 @@ impl MachineState {
 
     pub(super)
     fn execute_arith_instr(&mut self, instr: &ArithmeticInstruction) {
-        let stub = MachineError::functor_stub(clause_name!("(is)"), 2);
+        let stub = MachineError::functor_stub(clause_name!("is"), 2);
 
         match instr {
             &ArithmeticInstruction::Add(ref a1, ref a2, t) => {
@@ -1402,18 +1397,16 @@ impl MachineState {
                 let addr = self.store(self.deref(addr));
 
                 let offset = match addr {
-                    Addr::HeapCell(_) | Addr::StackCell(..) |
-                    Addr::AttrVar(..) | Addr::Stream(_) => {
-                      v
+                    Addr::Stream(_) | Addr::TcpListener(_) => {
+                        0
+                    }
+                    Addr::HeapCell(_) | Addr::StackCell(..) | Addr::AttrVar(..) => {
+                        v
                     }
                     Addr::PStrLocation(..) => {
-                        if !self.flags.double_quotes.is_atom() {
-                            l
-                        } else {
-                            c
-                        }
+                        l
                     }
-                    Addr::Char(_) | Addr::CharCode(_) | Addr::Con(_) | Addr::CutPoint(_) |
+                    Addr::Char(_) | Addr::Con(_) | Addr::CutPoint(_) |
                     Addr::EmptyList | Addr::Fixnum(_) | Addr::Float(_) | Addr::Usize(_) => {
                         c
                     }
@@ -1435,7 +1428,7 @@ impl MachineState {
                 let addr = self.store(self.deref(addr));
 
                 let offset =
-                    match addr.as_constant(&self) {
+                    match addr.as_constant_index(&self) {
                         Some(c) => {
                             match hm.get(&c) {
                                 Some(offset) => *offset,
@@ -1494,9 +1487,13 @@ impl MachineState {
             &QueryInstruction::PutPartialString(_, ref string, reg, has_tail) => {
                 let pstr_addr =
                     if has_tail {
-                        let pstr_addr = self.heap.allocate_pstr(&string);
-                        self.heap.pop(); // the tail will be added by the next instruction.
-                        pstr_addr
+                        if !string.is_empty() {
+                            let pstr_addr = self.heap.allocate_pstr(&string);
+                            self.heap.pop(); // the tail will be added by the next instruction.
+                            pstr_addr
+                        } else {
+                            Addr::EmptyList
+                        }
                     } else {
                         self.heap.put_complete_string(&string)
                     };
@@ -1595,7 +1592,8 @@ impl MachineState {
         );
     }
 
-    pub(super) fn handle_internal_call_n(&mut self, arity: usize) {
+    pub(super)
+    fn handle_internal_call_n(&mut self, arity: usize) {
         let arity = arity + 1;
         let pred = self.registers[1];
 
@@ -1611,7 +1609,8 @@ impl MachineState {
         self.fail = true;
     }
 
-    pub(super) fn setup_call_n(&mut self, arity: usize) -> Option<PredicateKey> {
+    pub(super)
+    fn setup_call_n(&mut self, arity: usize) -> Option<PredicateKey> {
         let addr = self.store(self.deref(self.registers[arity]));
 
         let (name, narity) = match addr {
@@ -1621,7 +1620,7 @@ impl MachineState {
                 if let HeapCellValue::NamedStr(narity, name, _) = result {
                     let stub = MachineError::functor_stub(clause_name!("call"), arity + 1);
 
-                    if narity + arity > 63 {
+                    if narity + arity > MAX_ARITY {
                         let representation_error = self.error_form(
                             MachineError::representation_error(RepFlag::MaxArity),
                             stub,
@@ -1881,14 +1880,33 @@ impl MachineState {
                         unreachable!()
                     }
                 }
-                (Addr::PStrLocation(..), Addr::Lis(_))
-              | (Addr::Lis(_), Addr::PStrLocation(..))
-                    if !self.flags.double_quotes.is_atom() => {
-                        continue;
-                    }
-                (Addr::PStrLocation(..), Addr::PStrLocation(..)) => {
+                (Addr::PStrLocation(..), Addr::Lis(_)) |
+                (Addr::Lis(_), Addr::PStrLocation(..)) => {
                     continue;
                 }
+                (pstr1 @ Addr::PStrLocation(..), pstr2 @ Addr::PStrLocation(..)) => {
+                    let mut i1 = self.heap_pstr_iter(pstr1);
+                    let mut i2 = self.heap_pstr_iter(pstr2);
+
+                    let ordering = compare_pstr_prefixes(&mut i1, &mut i2);
+
+                    if let Some(ordering) = ordering {
+                        if ordering != Ordering::Equal {
+                            return true;
+                        }
+                    }
+
+                    let (lstack, rstack) = iter.stack();
+
+                    lstack.pop();
+                    lstack.pop();
+
+                    rstack.pop();
+                    rstack.pop();
+
+                    lstack.push(i1.focus());
+                    rstack.push(i2.focus());
+                }
                 (Addr::Lis(_), Addr::Lis(_)) => {
                     continue;
                 }
@@ -1938,15 +1956,6 @@ impl MachineState {
                         }
                     }
                 }
-                (Addr::CharCode(n1), v2) | (v2, Addr::CharCode(n1)) => {
-                    if let Ok(n2) = Number::try_from((v2, &self.heap)) {
-                        if let Some(n2) = n2.to_u32() {
-                            if n1 != n2 {
-                                return true;
-                            }
-                        }
-                    }
-                }
                 (a1, a2) => {
                     if let Ok(n1) = Number::try_from((a1, &self.heap)) {
                         if let Ok(n2) = Number::try_from((a2, &self.heap)) {
@@ -1969,7 +1978,8 @@ impl MachineState {
         iter.first_to_expire != Ordering::Equal
     }
 
-    pub(super) fn compare_term_test(&self, a1: &Addr, a2: &Addr) -> Option<Ordering> {
+    pub(super)
+    fn compare_term_test(&self, a1: &Addr, a2: &Addr) -> Option<Ordering> {
         let mut iter = self.zipped_acyclic_pre_order_iter(*a1, *a2);
 
         while let Some((v1, v2)) = iter.next() {
@@ -2115,42 +2125,6 @@ impl MachineState {
                                 unreachable!()
                             }
                         }
-                        (
-                            Addr::Con(h),
-                            Addr::CharCode(c),
-                        ) => {
-                            let c = std::char::from_u32(c).unwrap();
-
-                            if let HeapCellValue::Atom(ref n1, _) = &self.heap[h] {
-                                if n1.is_char() {
-                                    if n1.as_str().chars().next() != Some(c) {
-                                        return Some(n1.as_str().chars().next().cmp(&Some(c)));
-                                    }
-                                } else {
-                                    return Some(Ordering::Greater);
-                                }
-                            } else {
-                                unreachable!()
-                            }
-                        }
-                        (
-                            Addr::CharCode(c),
-                            Addr::Con(h),
-                        ) => {
-                            let c = std::char::from_u32(c).unwrap();
-
-                            if let HeapCellValue::Atom(ref n1, _) = &self.heap[h] {
-                                if n1.is_char() {
-                                    if n1.as_str().chars().next() != Some(c) {
-                                        return Some(Some(c).cmp(&n1.as_str().chars().next()));
-                                    }
-                                } else {
-                                    return Some(Ordering::Less);
-                                }
-                            } else {
-                                unreachable!()
-                            }
-                        }
                         (
                             Addr::EmptyList,
                             Addr::Con(h),
@@ -2183,34 +2157,6 @@ impl MachineState {
                                 return Some(c1.cmp(&c2));
                             }
                         }
-                        (
-                            Addr::CharCode(c1),
-                            Addr::CharCode(c2),
-                        ) => {
-                            if c1 != c2 {
-                                return Some(c1.cmp(&c2));
-                            }
-                        }
-                        (
-                            Addr::Char(c1),
-                            Addr::CharCode(c2),
-                        ) => {
-                            let c2 = std::char::from_u32(c2).unwrap();
-
-                            if c1 != c2 {
-                                return Some(c1.cmp(&c2));
-                            }
-                        }
-                        (
-                            Addr::CharCode(c1),
-                            Addr::Char(c2),
-                        ) => {
-                            let c1 = std::char::from_u32(c1).unwrap();
-
-                            if c1 != c2 {
-                                return Some(c1.cmp(&c2));
-                            }
-                        }
                         (
                             Addr::Char(c),
                             Addr::EmptyList,
@@ -2231,30 +2177,6 @@ impl MachineState {
                                 Some('['.cmp(&c))
                             };
                         }
-                        (
-                            Addr::CharCode(c),
-                            Addr::EmptyList,
-                        ) => {
-                            let c = std::char::from_u32(c).unwrap();
-
-                            return if c == '[' {
-                                Some(Ordering::Less)
-                            } else {
-                                Some(c.cmp(&'['))
-                            };
-                        }
-                        (
-                            Addr::EmptyList,
-                            Addr::CharCode(c),
-                        ) => {
-                            let c = std::char::from_u32(c).unwrap();
-
-                            return if c == '[' {
-                                Some(Ordering::Greater)
-                            } else {
-                                Some('['.cmp(&c))
-                            };
-                        }
                         (
                             Addr::EmptyList,
                             Addr::EmptyList,
@@ -2273,9 +2195,30 @@ impl MachineState {
                         ) => {
                         }
                         (
-                            Addr::PStrLocation(..),
-                            Addr::PStrLocation(..),
+                            pstr1 @ Addr::PStrLocation(..),
+                            pstr2 @ Addr::PStrLocation(..),
                         ) => {
+                            let mut i1 = self.heap_pstr_iter(pstr1);
+                            let mut i2 = self.heap_pstr_iter(pstr2);
+
+                            let ordering = compare_pstr_prefixes(&mut i1, &mut i2);
+
+                            if let Some(ordering) = ordering {
+                                if ordering != Ordering::Equal {
+                                    return Some(ordering);
+                                }
+                            } else {
+                                let (lstack, rstack) = iter.stack();
+
+                                lstack.pop();
+                                lstack.pop();
+
+                                rstack.pop();
+                                rstack.pop();
+
+                                lstack.push(i1.focus());
+                                rstack.push(i2.focus());
+                            }
                         }
                         (
                             Addr::Str(h1),
@@ -2300,7 +2243,7 @@ impl MachineState {
                         (
                             Addr::PStrLocation(..),
                             Addr::Lis(_),
-                        ) if !self.flags.double_quotes.is_atom() => {
+                        ) => {
                         }
                         (
                             Addr::Lis(_),
@@ -2329,7 +2272,7 @@ impl MachineState {
                         (
                             Addr::PStrLocation(..),
                             Addr::Str(s),
-                        ) if !self.flags.double_quotes.is_atom() => {
+                        ) => {
                             if let &HeapCellValue::NamedStr(a1, ref n1, _) = &self.heap[s] {
                                 if a1 != 2 || n1.as_str() != "." {
                                     return Some(a1.cmp(&2).then_with(|| n1.as_str().cmp(".")));
@@ -2341,7 +2284,7 @@ impl MachineState {
                         (
                             Addr::Str(s),
                             Addr::PStrLocation(..),
-                        ) if !self.flags.double_quotes.is_atom() => {
+                        ) => {
                             if let &HeapCellValue::NamedStr(a1, ref n1, _) = &self.heap[s] {
                                 if a1 != 2 || n1.as_str() != "." {
                                     return Some(2.cmp(&a1).then_with(|| ".".cmp(n1.as_str())));
@@ -2400,7 +2343,12 @@ impl MachineState {
                 let d = self.store(self.deref(self[r1]));
 
                 match d {
-                    Addr::Con(_) => self.p += 1,
+                    Addr::Char(_) |
+                    Addr::Con(_) |
+                    Addr::EmptyList |
+                    Addr::Fixnum(_) |
+                    Addr::Float(_) |
+                    Addr::Usize(_) => self.p += 1,
                     _ => self.fail = true,
                 };
             }
@@ -2422,17 +2370,7 @@ impl MachineState {
                         }
                     }
                     _ => {
-                        match d {
-                            Addr::CharCode(_) => {
-                                self.p += 1;
-                            }
-                            Addr::Char(_) if self.flags.double_quotes.is_codes() => {
-                                self.p += 1;
-                            }
-                            _ => {
-                                self.fail = true;
-                            }
-                        }
+                        self.fail = true;
                     }
                 }
             }
@@ -2523,22 +2461,29 @@ impl MachineState {
     fn try_functor_fabricate_struct(
         &mut self,
         name: ClauseName,
-        arity: isize,
+        arity: usize,
         spec: Option<SharedOpDesc>,
         op_dir: &OpDir,
         r: Ref,
     ) {
-        let spec = fetch_atom_op_spec(name.clone(), spec, op_dir);
+        let spec = spec.and_then(|spec| {
+            if spec.arity() != arity {
+                fetch_op_spec(name.clone(), arity, op_dir)
+            } else {
+                Some(spec)
+            }
+        });
 
         let f_a = if name.as_str() == "." && arity == 2 {
             Addr::Lis(self.heap.h())
         } else {
-            self.heap.to_unifiable(HeapCellValue::NamedStr(arity as usize, name, spec))
+            self.heap.to_unifiable(HeapCellValue::NamedStr(arity, name, spec))
         };
 
-        for _ in 0..arity {
-            let h = self.heap.h();
-            self.heap.push(HeapCellValue::Addr(Addr::HeapCell(h)));
+        let h = self.heap.h();
+
+        for i in 0 .. arity {
+            self.heap.push(HeapCellValue::Addr(Addr::HeapCell(h + i)));
         }
 
         self.bind(r, f_a);
@@ -2553,13 +2498,19 @@ impl MachineState {
             Addr::Stream(_) => {
                 self.fail = true;
             }
-            Addr::Char(_) | Addr::CharCode(_) | Addr::Con(_) | Addr::Fixnum(_) |
+            Addr::Char(_) | Addr::Con(_) | Addr::Fixnum(_) |
             Addr::Float(_) | Addr::EmptyList | Addr::Usize(_) => {
                 self.try_functor_unify_components(a1, 0);
             }
             Addr::Str(o) => match self.heap.clone(o) {
                 HeapCellValue::NamedStr(arity, name, spec) => {
-                    let spec = fetch_op_spec(name.clone(), arity, spec, &indices.op_dir);
+                    let spec = fetch_op_spec_from_existing(
+                        name.clone(),
+                        arity,
+                        spec,
+                        &indices.op_dir,
+                    );
+
                     self.try_functor_compound_case(name, arity, spec)
                 }
                 _ => {
@@ -2567,7 +2518,13 @@ impl MachineState {
                 }
             },
             Addr::Lis(_) | Addr::PStrLocation(..) => {
-                let spec = fetch_op_spec(clause_name!("."), 2, None, &indices.op_dir);
+                let spec = fetch_op_spec_from_existing(
+                    clause_name!("."),
+                    2,
+                    None,
+                    &indices.op_dir,
+                );
+
                 self.try_functor_compound_case(clause_name!("."), 2, spec)
             }
             Addr::AttrVar(..) | Addr::HeapCell(_) | Addr::StackCell(..) => {
@@ -2589,9 +2546,6 @@ impl MachineState {
                             },
                         _ =>
                             match arity {
-                                Addr::CharCode(c) => {
-                                    Some(c as isize)
-                                }
                                 arity => {
                                     return Err(
                                         self.error_form(
@@ -2633,7 +2587,7 @@ impl MachineState {
                 }
 
                 match name {
-                    Addr::Char(_) | Addr::CharCode(_) | Addr::Con(_) | Addr::Fixnum(_) | Addr::Float(_) |
+                    Addr::Char(_) | Addr::Con(_) | Addr::Fixnum(_) | Addr::Float(_) |
                     Addr::EmptyList | Addr::PStrLocation(..) | Addr::Usize(_) if arity == 0 => {
                         self.unify(a1, name);
                     }
@@ -2641,7 +2595,7 @@ impl MachineState {
                         if let HeapCellValue::Atom(name, spec) = self.heap.clone(h) {
                             self.try_functor_fabricate_struct(
                                 name,
-                                arity,
+                                arity as usize,
                                 spec,
                                 &indices.op_dir,
                                 a1.as_var().unwrap(),
@@ -2661,7 +2615,7 @@ impl MachineState {
                     Addr::Char(c) => {
                         self.try_functor_fabricate_struct(
                             clause_name!(c.to_string(), indices.atom_tbl),
-                            arity,
+                            arity as usize,
                             None,
                             &indices.op_dir,
                             a1.as_var().unwrap(),
@@ -2700,6 +2654,51 @@ impl MachineState {
         *list = result;
     }
 
+
+    pub(super)
+    fn integers_to_bytevec(
+        &self,
+        r: RegType,
+        caller: MachineStub,
+    ) -> Vec<u8> {
+
+        let mut bytes: Vec<u8> = Vec::new();
+
+        match self.try_from_list(r, caller) {
+            Err(_) => { unreachable!() }
+            Ok(addrs) => {
+
+                for addr in addrs {
+                    let addr = self.store(self.deref(addr));
+
+                    match Number::try_from((addr, &self.heap)) {
+                        Ok(Number::Fixnum(n)) => {
+                            match u8::try_from(n) {
+                                Ok(b) => {
+                                    bytes.push(b);
+                                }
+                                Err(_) => { }
+                            }
+
+                            continue;
+                        }
+                        Ok(Number::Integer(n)) => {
+                            if let Some(b) = n.to_u8() {
+                               bytes.push(b);
+                            }
+
+                            continue;
+                        }
+                        _ => {
+                        }
+                    }
+                }
+            }
+        }
+        bytes
+    }
+
+
     pub(super)
     fn try_from_list(
         &self,
@@ -2862,7 +2861,8 @@ impl MachineState {
         }
     }
 
-    pub(super) fn copy_term(&mut self, attr_var_policy: AttrVarPolicy) {
+    pub(super)
+    fn copy_term(&mut self, attr_var_policy: AttrVarPolicy) {
         let old_h = self.heap.h();
 
         let a1 = self[temp_v!(1)];
@@ -2874,7 +2874,8 @@ impl MachineState {
     }
 
     // returns true on failure.
-    pub(super) fn structural_eq_test(&self) -> bool {
+    pub(super)
+    fn structural_eq_test(&self) -> bool {
         let a1 = self[temp_v!(1)];
         let a2 = self[temp_v!(2)];
 
@@ -2894,7 +2895,7 @@ impl MachineState {
                 | (
                     HeapCellValue::Addr(Addr::PStrLocation(..)),
                     HeapCellValue::Addr(Addr::Lis(_)),
-                ) if !self.flags.double_quotes.is_atom() => {
+                ) => {
                 }
                 (
                     HeapCellValue::NamedStr(ar1, n1, _),
@@ -3083,6 +3084,14 @@ impl MachineState {
         self.p += 1;
     }
 
+    fn throw_interrupt_exception(&mut self) {
+        let err = MachineError::interrupt_error();
+        let src = functor!("repl");
+        let err = self.error_form(err, src);
+
+        self.throw_exception(err);
+    }
+
     fn handle_call_clause(
         &mut self,
         indices: &mut IndexStore,
@@ -3099,8 +3108,7 @@ impl MachineState {
 	    let interrupted = INTERRUPT.load(std::sync::atomic::Ordering::Relaxed);
 
 	    if INTERRUPT.compare_and_swap(interrupted, false, std::sync::atomic::Ordering::Relaxed) {
-	        self.reset();
-	        self.fail = true;
+            self.throw_interrupt_exception();
 	        return;
 	    }
 
@@ -3160,7 +3168,8 @@ impl MachineState {
         self.last_call = false;
     }
 
-    pub(super) fn execute_ctrl_instr(
+    pub(super)
+    fn execute_ctrl_instr(
         &mut self,
         indices: &mut IndexStore,
         code_repo: &CodeRepo,

src/machine/mod.rs

@@ -1,12 +1,12 @@
-use prolog_parser::ast::*;
-use prolog_parser::tabled_rc::*;
+use crate::prolog_parser::ast::*;
+use crate::prolog_parser::tabled_rc::*;
 
-use crate::prolog::clause_types::*;
-use crate::prolog::forms::*;
-use crate::prolog::heap_print::*;
-use crate::prolog::instructions::*;
-use crate::prolog::machine::heap::*;
-use crate::prolog::read::*;
+use crate::clause_types::*;
+use crate::forms::*;
+use crate::heap_print::*;
+use crate::instructions::*;
+use crate::machine::heap::*;
+use crate::read::*;
 
 mod attributed_variables;
 pub(super) mod code_repo;
@@ -32,17 +32,17 @@ mod arithmetic_ops;
 mod machine_state_impl;
 mod system_calls;
 
-use crate::prolog::machine::attributed_variables::*;
-use crate::prolog::machine::code_repo::*;
-use crate::prolog::machine::compile::*;
-use crate::prolog::machine::machine_errors::*;
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::machine::machine_state::*;
-use crate::prolog::machine::modules::*;
-use crate::prolog::machine::streams::*;
-use crate::prolog::machine::toplevel::*;
+use crate::machine::attributed_variables::*;
+use crate::machine::code_repo::*;
+use crate::machine::compile::*;
+use crate::machine::machine_errors::*;
+use crate::machine::machine_indices::*;
+use crate::machine::machine_state::*;
+use crate::machine::modules::*;
+use crate::machine::streams::*;
+use crate::machine::toplevel::*;
 
-use indexmap::IndexMap;
+use crate::indexmap::IndexMap;
 
 use std::collections::VecDeque;
 use std::convert::TryFrom;
@@ -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>,
@@ -72,6 +73,14 @@ impl MachinePolicies {
     }
 }
 
+impl Default for MachinePolicies {
+    #[inline]
+    fn default() -> Self {
+        MachinePolicies::new()
+    }
+}
+
+#[derive(Debug)]
 pub struct Machine {
     pub(super) machine_st: MachineState,
     pub(super) inner_heap: Heap,
@@ -203,17 +212,6 @@ impl SubModuleUser for IndexStore {
     }
 }
 
-#[inline]
-fn current_dir() -> std::path::PathBuf {
-    let mut path_buf = std::path::PathBuf::from(PROJECT_DIR);
-
-    // file!() always produces a path relative to PROJECT_DIR.
-    path_buf = path_buf.join(std::path::PathBuf::from(file!()));
-
-    path_buf.pop();
-    path_buf
-}
-
 include!(concat!(env!("OUT_DIR"), "/libraries.rs"));
 
 static TOPLEVEL: &str = include_str!("../toplevel.pl");
@@ -221,12 +219,7 @@ static TOPLEVEL: &str = include_str!("../toplevel.pl");
 impl Machine {
     fn compile_special_forms(&mut self)
     {
-        let current_dir = current_dir();
-
-        let verify_attrs_src = ListingSource::from_file_and_path(
-            clause_name!("attributed_variables.pl"),
-            current_dir.clone(),
-        );
+        let verify_attrs_src = ListingSource::User;
 
         match compile_special_form(
             self,
@@ -241,10 +234,7 @@ impl Machine {
                 panic!("Machine::compile_special_forms() failed at VERIFY_ATTRS"),
         }
 
-        let project_attrs_src = ListingSource::from_file_and_path(
-            clause_name!("project_attributes.pl"),
-            current_dir,
-        );
+        let project_attrs_src = ListingSource::User;
 
         match compile_special_form(
             self,
@@ -264,13 +254,7 @@ impl Machine {
     {
         self.toplevel_idx = self.code_repo.code.len();
 
-        let mut current_dir = current_dir();
-        current_dir.pop();
-
-        let top_lvl_src = ListingSource::from_file_and_path(
-            clause_name!("toplevel.pl"),
-            current_dir,
-        );
+        let top_lvl_src = ListingSource::User;
 
         compile_user_module(
             self,
@@ -288,7 +272,7 @@ impl Machine {
 
             Ok(self.indices.insert_module(module))
         } else {
-            let err = ExistenceError::SourceSink(ModuleSource::File(
+            let err = ExistenceError::ModuleSource(ModuleSource::File(
                 clause_name!("$toplevel"),
             ));
 
@@ -306,7 +290,10 @@ impl Machine {
 
         if path.is_file() {
             let file_src = match File::open(&path) {
-                Ok(file_handle) => Stream::from(file_handle),
+                Ok(file_handle) => Stream::from_file_as_input(
+                    clause_name!(".scryerrc"),
+                    file_handle,
+                ),
                 Err(_) => return,
             };
 
@@ -340,28 +327,27 @@ impl Machine {
     }
 
     pub fn run_top_level(&mut self) {
-	    use std::env;
+        use std::env;
 
-	    let mut filename_atoms = vec![];
+        let mut arg_pstrs = vec![];
 
-	    // the first of these is the path to the scryer-prolog executable, so skip
-	    // it.
-	    for filename in env::args().skip(1) {
-	        let atom = clause_name!(filename, self.indices.atom_tbl);
-	        filename_atoms.push(HeapCellValue::Atom(atom, None));
-	    }
+        for arg in env::args() {
+            arg_pstrs.push(self.machine_st.heap.put_complete_string(&arg));
+        }
 
-	    let list_addr =
-	        Addr::HeapCell(self.machine_st.heap.to_list(filename_atoms.into_iter()));
+        let list_addr = Addr::HeapCell(self.machine_st.heap.to_list(arg_pstrs.into_iter()));
+        self.machine_st[temp_v!(1)] = list_addr;
 
-	    self.machine_st[temp_v!(1)] = list_addr;
-        self.machine_st.p = CodePtr::Local(LocalCodePtr::DirEntry(self.toplevel_idx));
-
-        self.run_query();
+        loop {
+            self.machine_st.p = CodePtr::Local(LocalCodePtr::DirEntry(self.toplevel_idx));
+            self.run_query();
+        }
     }
 
     pub fn new(current_input_stream: Stream, current_output_stream: Stream) -> Self
     {
+        use crate::ref_thread_local::RefThreadLocal;
+
         let mut wam = Machine {
             machine_st: MachineState::new(),
             inner_heap: Heap::new(),
@@ -374,60 +360,59 @@ impl Machine {
         };
 
         let atom_tbl = wam.indices.atom_tbl.clone();
-        let mut lib_path = current_dir();
-
-        lib_path.pop();
-        lib_path.push("lib");
 
         wam.indices.add_term_and_goal_expansion_indices();
 
         compile_listing(
             &mut wam,
-            Stream::from(BUILTINS),
+            Stream::from(LIBRARIES.borrow()["builtins"]),
             default_index_store!(atom_tbl.clone()),
             true,
-            ListingSource::from_file_and_path(
-                clause_name!("builtins.pl"),
-                lib_path.clone(),
-            ),
+            ListingSource::User,
         );
 
         wam.compile_special_forms();
 
-        compile_user_module(&mut wam,
-                            Stream::from(ERROR),
-                            true,
-                            ListingSource::from_file_and_path(
-                                clause_name!("error"),
-                                lib_path.clone(),
-                            )
+        compile_user_module(
+            &mut wam,
+            Stream::from(LIBRARIES.borrow()["error"]),
+            true,
+            ListingSource::User,
         );
 
-        compile_user_module(&mut wam,
-                            Stream::from(LISTS),
-                            true,
-                            ListingSource::from_file_and_path(
-                                clause_name!("lists"),
-                                lib_path.clone(),
-                            ),
+        compile_user_module(
+            &mut wam,
+            Stream::from(LIBRARIES.borrow()["pairs"]),
+            true,
+            ListingSource::User,
         );
 
-        compile_user_module(&mut wam,
-                            Stream::from(ISO_EXT),
-                            true,
-                            ListingSource::from_file_and_path(
-                                clause_name!("iso_ext"),
-                                lib_path.clone(),
-                            )
+        compile_user_module(
+            &mut wam,
+            Stream::from(LIBRARIES.borrow()["lists"]),
+            true,
+            ListingSource::User,
         );
 
-        compile_user_module(&mut wam,
-                            Stream::from(SI),
-                            true,
-                            ListingSource::from_file_and_path(
-                                clause_name!("si"),
-                                lib_path.clone(),
-                            )
+        compile_user_module(
+            &mut wam,
+            Stream::from(LIBRARIES.borrow()["iso_ext"]),
+            true,
+            ListingSource::User,
+        );
+
+        compile_user_module(
+            &mut wam,
+            Stream::from(LIBRARIES.borrow()["si"]),
+            true,
+            ListingSource::User,
+        );
+
+        compile_user_module(
+            &mut wam,
+            Stream::from(LIBRARIES.borrow()["charsio"]),
+            true,
+            ListingSource::User,
         );
 
         if wam.compile_top_level().is_err() {
@@ -435,10 +420,35 @@ impl Machine {
         }
 
         wam.compile_scryerrc();
+        wam.configure_streams();
 
         wam
     }
 
+    pub fn configure_streams(&mut self) {
+        self.current_input_stream.options.alias = Some(clause_name!("user_input"));
+
+        self.indices.stream_aliases.insert(
+            clause_name!("user_input"),
+            self.current_input_stream.clone(),
+        );
+
+        self.indices.streams.insert(
+            self.current_input_stream.clone()
+        );
+
+        self.current_output_stream.options.alias = Some(clause_name!("user_output"));
+
+        self.indices.stream_aliases.insert(
+            clause_name!("user_output"),
+            self.current_output_stream.clone(),
+        );
+
+        self.indices.streams.insert(
+            self.current_output_stream.clone()
+        );
+    }
+
     #[inline]
     pub fn machine_flags(&self) -> MachineFlags {
         self.machine_st.flags
@@ -625,8 +635,19 @@ impl Machine {
             let addr = self.machine_st.store(self.machine_st.deref(module_spec));
 
             match self.machine_st.heap.index_addr(&addr).as_ref() {
-                HeapCellValue::Atom(name, _) => name.clone(),
-	            _ => unreachable!(),
+                HeapCellValue::Atom(name, _) =>
+                    name.clone(),
+                HeapCellValue::Addr(Addr::Char(c)) =>
+                    clause_name!(c.to_string(), self.indices.atom_tbl),
+                HeapCellValue::Addr(addr @ Addr::PStrLocation(..)) => {
+                    let mut heap_pstr_iter =
+                        self.machine_st.heap_pstr_iter(*addr);
+                    clause_name!(
+                        heap_pstr_iter.to_string(),
+                        self.indices.atom_tbl
+                    )
+                }
+                _ => unreachable!(),
             }
 	    };
 
@@ -672,8 +693,12 @@ impl Machine {
             let addr = self.machine_st.store(self.machine_st.deref(module_spec));
 
             match self.machine_st.heap.index_addr(&addr).as_ref() {
-                HeapCellValue::Atom(name, _) => name.clone(),
-	            _ => unreachable!(),
+                HeapCellValue::Atom(name, _) =>
+                    name.clone(),
+                HeapCellValue::Addr(Addr::Char(c)) =>
+                    clause_name!(c.to_string(), self.indices.atom_tbl),
+	            _ =>
+                    unreachable!(),
             }
 	    };
 

src/machine/modules.rs

@@ -1,10 +1,10 @@
-use prolog_parser::ast::*;
-use prolog_parser::tabled_rc::*;
+use crate::prolog_parser::ast::*;
+use crate::prolog_parser::tabled_rc::*;
 
-use crate::prolog::forms::*;
-use crate::prolog::machine::code_repo::*;
-use crate::prolog::machine::machine_errors::*;
-use crate::prolog::machine::machine_indices::*;
+use crate::forms::*;
+use crate::machine::code_repo::*;
+use crate::machine::machine_errors::*;
+use crate::machine::machine_indices::*;
 
 use std::collections::VecDeque;
 use std::mem;
@@ -48,6 +48,7 @@ impl Module {
             (te.0)
                 .0
                 .extend((self.user_term_expansions.0).0.iter().cloned());
+
             te.1.extend(self.user_term_expansions.1.iter().cloned());
         }
 
@@ -60,6 +61,7 @@ impl Module {
             (ge.0)
                 .0
                 .extend((self.user_goal_expansions.0).0.iter().cloned());
+
             ge.1.extend(self.user_goal_expansions.1.iter().cloned());
         }
 
@@ -166,7 +168,7 @@ pub trait SubModuleUser {
                                     }
                                 }
                             }
-                        }                    
+                        }
                         _ => {}
                     };
                 },
@@ -202,7 +204,7 @@ pub trait SubModuleUser {
         _: &Module,
         _: &Vec<ModuleExport>,
     ) -> Result<(), SessionError>;
-    
+
     fn use_module(
         &mut self,
         _: &mut CodeRepo,
@@ -232,7 +234,7 @@ where
 
                 if !user.import_decl(name.clone(), arity, submodule) {
                     let submodule_name = submodule.module_decl.name.clone();
-                    
+
                     return Err(SessionError::ModuleDoesNotContainExport(
                         submodule_name,
                         (name, arity)
@@ -250,12 +252,12 @@ where
 
                 let op_dir = user.op_dir();
                 let prec = op_decl.0;
-                
+
                 op_decl.insert_into_op_dir(
                     submodule.module_decl.name.clone(),
                     op_dir,
                     prec,
-                );                   
+                );
             }
         }
     }
@@ -282,12 +284,12 @@ pub fn use_module<User: SubModuleUser>(
             ModuleExport::OpDecl(op_decl) => {
                 let op_dir = user.op_dir();
                 let prec = op_decl.0;
-                
+
                 op_decl.insert_into_op_dir(
                     submodule.module_decl.name.clone(),
                     op_dir,
                     prec,
-                );                
+                );
             }
         }
     }

src/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,
@@ -36,8 +37,8 @@ fn scan_for_terminator<Iter: Iterator<Item = char>>(iter: Iter) -> usize {
     let mut terminator_idx = 0;
 
     for c in iter {
-        if c == '\u{0}' {
-            break;
+        if c == '\u{0}' && terminator_idx != 0 {
+            return terminator_idx;
         }
 
         terminator_idx += c.len_utf8();
@@ -46,15 +47,18 @@ fn scan_for_terminator<Iter: Iterator<Item = char>>(iter: Iter) -> usize {
     terminator_idx
 }
 
+#[derive(Debug)]
 pub struct PStrIter {
     buf: *const u8,
+    len: usize,
 }
 
 impl PStrIter {
     #[inline]
-    fn from(buf: *const u8, idx: usize) -> Self {
+    fn from(buf: *const u8, len: usize, idx: usize) -> Self {
         PStrIter {
-            buf: (buf as usize + idx) as *const _
+            buf: (buf as usize + idx) as *const _,
+            len: len - idx,
         }
     }
 }
@@ -64,27 +68,13 @@ impl Iterator for PStrIter {
 
     fn next(&mut self) -> Option<Self::Item> {
         unsafe {
-            let mut byte_count = 0;
-
-            for n in 0 .. mem::size_of::<char>() {
-                let b = ptr::read((self.buf as usize + n) as *const u8);
-
-                if b == 0u8 {
-                    break;
-                } else {
-                    byte_count += 1;
-                }
-            }
-
-            if byte_count == 0 {
-                return None;
-            }
-
-            let slice = slice::from_raw_parts(self.buf, byte_count);
+            let slice = slice::from_raw_parts(self.buf, self.len);
             let s = str::from_utf8(slice).unwrap();
 
             if let Some(c) = s.chars().next() {
                 self.buf = self.buf.offset(c.len_utf8() as isize);
+                self.len -= c.len_utf8();
+
                 Some(c)
             } else {
                 None
@@ -108,37 +98,9 @@ impl PartialString {
         }
     }
 
-    #[inline]
-    pub(super)
-    fn empty() -> Self {
-        let mut pstr = PartialString {
-            buf: ptr::null(),
-            len: 0,
-            _marker: PhantomData,
-        };
-
-        unsafe {
-            let layout = alloc::Layout::from_size_align_unchecked(
-                '\u{0}'.len_utf8(),
-                mem::align_of::<u8>(),
-            );
-
-            pstr.buf = alloc::alloc(layout) as *const _;
-            pstr.len = '\u{0}'.len_utf8();
-
-            pstr.write_terminator_at(0);
-        }
-
-        pstr
-    }
-
     unsafe fn append_chars(mut self, src: &str) -> Option<(Self, &str)> {
         let terminator_idx = scan_for_terminator(src.chars());
 
-        if terminator_idx == 0 {
-            return None;
-        }
-
         let layout = alloc::Layout::from_size_align_unchecked(
             terminator_idx + '\u{0}'.len_utf8(),
             mem::align_of::<u8>(),
@@ -155,8 +117,8 @@ impl PartialString {
 
         self.write_terminator_at(terminator_idx);
 
-        Some(if terminator_idx != src.len() {
-            (self, &src[terminator_idx + '\u{0}'.len_utf8() ..])
+        Some(if terminator_idx != src.as_bytes().len() {
+            (self, &src[terminator_idx ..])
         } else {
             (self, "")
         })
@@ -212,14 +174,16 @@ impl PartialString {
 
     #[inline]
     pub fn range_from(&self, index: RangeFrom<usize>) -> PStrIter {
-        PStrIter::from(self.buf, index.start)
+        if self.len >= '\u{0}'.len_utf8() {
+            PStrIter::from(self.buf, self.len - '\u{0}'.len_utf8(), index.start)
+        } else {
+            PStrIter::from(self.buf, 0, 0)
+        }
     }
 
     #[inline]
     pub fn at_end(&self, end_n: usize) -> bool {
-        unsafe {
-            ptr::read((self.buf as usize + end_n) as *const u8) == 0u8
-        }
+        end_n + 1 == self.len
     }
 
     #[inline]

src/machine/project_attributes.pl

@@ -1,3 +1,5 @@
+:- module('$project_atts', [copy_term/3]).
+
 '$attribute_goals_driver'(QueryVars, AttrVars) :-
     gather_modules(AttrVars, Modules0, _),
     sort(Modules0, Modules),
@@ -99,7 +101,7 @@ call_attribute_goals_with_module_prefix([Module | Modules], GoalCaller, AttrVars
     call_attribute_goals_with_module_prefix(Modules, GoalCaller, AttrVars, Gs).
 
 copy_term(Source, Dest, Goals) :-
-    term_variables(Source, Vars),
+    '$term_attributed_variables'(Source, Vars),
     gather_modules(Vars, Modules0, _),
     sort(Modules0, Modules),
     call_attribute_goals_with_module_prefix(Modules, call_query_var_goals, Vars, Goals0),

src/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/machine/stack.rs

@@ -1,12 +1,13 @@
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::machine::raw_block::*;
-
 use core::marker::PhantomData;
 
+use crate::machine::machine_indices::*;
+use crate::machine::raw_block::*;
+
 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,
 }
@@ -165,16 +171,19 @@ impl Stack {
 
         unsafe {
             let new_top = self.buf.new_block(frame_size);
+            let e = self.buf.top as usize - self.buf.base as usize;
 
             for idx in 0 .. num_cells {
                 let offset = prelude_size::<AndFramePrelude>() + idx * mem::size_of::<Addr>();
-                ptr::write((self.buf.top as usize + offset) as *mut Addr, Addr::StackCell(0,0));
+                ptr::write(
+                    (self.buf.top as usize + offset) as *mut Addr,
+                    Addr::StackCell(e, idx + 1),
+                );
             }
 
             let and_frame = &mut *(self.buf.top as *mut AndFrame);
             and_frame.prelude.univ_prelude.num_cells = num_cells;
 
-            let e = self.buf.top as usize - self.buf.base as usize;
             self.buf.top = new_top;
 
             e
@@ -186,16 +195,19 @@ impl Stack {
 
         unsafe {
             let new_top = self.buf.new_block(frame_size);
+            let b = self.buf.top as usize - self.buf.base as usize;
 
             for idx in 0 .. num_cells {
                 let offset = prelude_size::<OrFramePrelude>() + idx * mem::size_of::<Addr>();
-                ptr::write((self.buf.top as usize + offset) as *mut Addr, Addr::StackCell(0,0));
+                ptr::write(
+                    (self.buf.top as usize + offset) as *mut Addr,
+                    Addr::StackCell(b, idx),
+                );
             }
 
             let or_frame = &mut *(self.buf.top as *mut OrFrame);
             or_frame.prelude.univ_prelude.num_cells = num_cells;
 
-            let b = self.buf.top as usize - self.buf.base as usize;
             self.buf.top = new_top;
 
             b

src/machine/term_expansion.rs

@@ -1,10 +1,10 @@
-use prolog_parser::ast::*;
-use prolog_parser::parser::*;
+use crate::prolog_parser::ast::*;
+use crate::prolog_parser::parser::*;
 
-use crate::prolog::machine::machine_indices::HeapCellValue;
-use crate::prolog::machine::*;
-use crate::prolog::rug::ops::Pow;
-use crate::prolog::rug::Integer;
+use crate::machine::machine_indices::HeapCellValue;
+use crate::machine::*;
+use crate::rug::ops::Pow;
+use crate::rug::Integer;
 
 use std::cell::Cell;
 use std::collections::VecDeque;
@@ -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>),
@@ -163,7 +165,7 @@ impl<'a> TermStream<'a> {
 
     #[inline]
     pub fn eof(&mut self) -> Result<bool, ParserError> {
-	self.parser.devour_whitespace()?; // eliminate dangling comments before checking for EOF.
+	    self.parser.devour_whitespace()?; // eliminate dangling comments before checking for EOF.
         Ok(self.stack.is_empty() && self.parser.eof()?)
     }
 
@@ -179,6 +181,7 @@ impl<'a> TermStream<'a> {
             te_len,
             te_queue_len,
         );
+
         let goal_expansion_additions = self.wam.code_repo.truncate_terms(
             (clause_name!("goal_expansion"), 2),
             ge_len,
@@ -218,7 +221,7 @@ impl<'a> TermStream<'a> {
         term_string: &str,
         op_dir: &OpDir,
     ) -> Result<Term, ParserError> {
-        let mut stream = parsing_stream(term_string.trim().as_bytes());
+        let mut stream = parsing_stream(term_string.trim().as_bytes())?;
         let mut parser = Parser::new(&mut stream, self.parser.get_atom_tbl(), self.flags);
 
         parser.read_term(composite_op!(
@@ -368,7 +371,7 @@ impl MachineState {
 
         self.query_stepper(
             &mut wam.indices,
-            &mut wam.policies,
+            &mut MachinePolicies::default(),
             &mut wam.code_repo,
             &mut readline::input_stream(),
             &mut Stream::stdout(),

src/machine/toplevel.rs

@@ -1,19 +1,20 @@
-use prolog_parser::ast::*;
-use prolog_parser::tabled_rc::*;
+use crate::prolog_parser::ast::*;
+use crate::prolog_parser::tabled_rc::*;
 
-use crate::prolog::forms::*;
-use crate::prolog::iterators::*;
-use crate::prolog::machine::machine_errors::*;
-use crate::prolog::machine::machine_indices::*;
-use crate::prolog::machine::term_expansion::*;
-use crate::prolog::machine::*;
+use crate::forms::*;
+use crate::iterators::*;
+use crate::machine::machine_errors::*;
+use crate::machine::machine_indices::*;
+use crate::machine::term_expansion::*;
+use crate::machine::*;
 
-use indexmap::{IndexMap, IndexSet};
+use crate::indexmap::{IndexMap, IndexSet};
 
 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>,
@@ -329,16 +340,37 @@ fn setup_module_decl(
     }
 }
 
-fn setup_use_module_decl(mut terms: Vec<Box<Term>>) -> Result<ModuleSource, ParserError> {
+fn read_library_path(
+    term: Term,
+    atom_tbl: TabledData<Atom>,
+) -> Option<ClauseName> {
+    match term {
+        Term::Constant(_, Constant::Atom(atom, _)) => {
+            Some(atom.defrock_brackets())
+        }
+        _ => {
+            let mut atoms = vec![];
+
+            for term in unfold_by_str(term, "/") {
+                match term {
+                    Term::Constant(_, Constant::Atom(atom, _)) => {
+                        atoms.push(atom.as_str().to_owned());
+                    }
+                    _ => return None,
+                }
+            }
+
+            Some(clause_name!(atoms.join("/"), atom_tbl))
+        }
+    }
+}
+
+fn setup_use_module_decl(mut terms: Vec<Box<Term>>, atom_tbl: TabledData<Atom>) -> Result<ModuleSource, ParserError> {
     match *terms.pop().unwrap() {
         Term::Clause(_, ref name, ref mut terms, None)
             if name.as_str() == "library" && terms.len() == 1 =>
         {
-            terms
-                .pop()
-                .unwrap()
-                .to_constant()
-                .and_then(|c| c.to_atom())
+            read_library_path(*terms.pop().unwrap(), atom_tbl)
                 .map(|c| ModuleSource::Library(c))
                 .ok_or(ParserError::InvalidUseModuleDecl)
         }
@@ -385,11 +417,7 @@ fn setup_qualified_import(
         Term::Clause(_, ref name, ref mut terms, None)
             if name.as_str() == "library" && terms.len() == 1 =>
         {
-            terms
-                .pop()
-                .unwrap()
-                .to_constant()
-                .and_then(|c| c.to_atom())
+            read_library_path(*terms.pop().unwrap(), atom_tbl.clone())
                 .map(|c| ModuleSource::Library(c))
                 .ok_or(ParserError::InvalidUseModuleDecl)
         }
@@ -642,7 +670,7 @@ fn setup_declaration<'a, 'b, 'c>(
 		        }
 		        ("initialization", 1) => {
 		            let mut rel_worker = RelationWorker::new(flags, line_num, col_num);
-		            let query_terms = rel_worker.setup_query(indices, terms, false)?;
+		            let (query_terms, _) = rel_worker.setup_query(indices, terms, false, false)?;
 		            let queue = rel_worker.parse_queue(indices)?;
 
 		            Ok(Declaration::ModuleInitialization(query_terms, queue))
@@ -674,7 +702,7 @@ fn setup_declaration<'a, 'b, 'c>(
                     }
                 }
 		        ("use_module", 1) => {
-		            Ok(Declaration::UseModule(setup_use_module_decl(terms)?))
+		            Ok(Declaration::UseModule(setup_use_module_decl(terms, indices.atom_tbl())?))
                 }
 		        ("use_module", 2) => {
 		            let (name, exports) = setup_qualified_import(terms, indices.atom_tbl())?;
@@ -690,6 +718,7 @@ fn setup_declaration<'a, 'b, 'c>(
     }
 }
 
+#[derive(Debug)]
 struct RelationWorker {
     flags: MachineFlags,
     dynamic_clauses: Vec<(Term, Term)>, // Head, Body.
@@ -860,6 +889,7 @@ impl RelationWorker {
                     let term = Term::Clause(Cell::default(), clause_name!(";"), terms, None);
                     let (stub, clauses) = self.fabricate_disjunct(term);
 
+                    debug_assert!(clauses.len() > 0);
                     self.queue.push_back(clauses);
                     Ok(QueryTerm::Jump(stub))
                 }
@@ -911,11 +941,14 @@ impl RelationWorker {
         indices: &mut CompositeIndices<'a, 'b, 'c>,
         terms: Vec<Box<Term>>,
         blocks_cuts: bool,
-    ) -> Result<Vec<QueryTerm>, ParserError> {
+        assume_dyn: bool,
+    ) -> Result<(Vec<QueryTerm>, Term), ParserError> {
         let mut query_terms = vec![];
         let mut work_queue = VecDeque::from(terms);
         let mut machine_st = MachineState::new();
 
+        let mut dynamic_clause_terms = vec![];
+
         while let Some(term) = work_queue.pop_front() {
             let term = *term;
             let op_dir = op_dir(&indices.index_src);
@@ -934,7 +967,7 @@ impl RelationWorker {
                 let mut term = *term;
 
                 if let Term::Clause(cell, name, terms, op_spec) = term {
-                    if name.as_str() == "," {
+                    if name.as_str() == "," && terms.len() == 2 {
                         let term = Term::Clause(cell, name, terms, op_spec);
                         let mut subterms = unfold_by_str(term, ",");
 
@@ -952,11 +985,22 @@ impl RelationWorker {
                     mark_cut_variable(&mut term);
                 }
 
+                if assume_dyn {
+                    dynamic_clause_terms.push(term.clone());
+                }
+
                 query_terms.push(self.pre_query_term(indices, term)?);
             }
         }
 
-        Ok(query_terms)
+        let dynamic_clause_body =
+            if let Some(term) = dynamic_clause_terms.pop() {
+                fold_by_str(dynamic_clause_terms.into_iter(), term, clause_name!(","))
+            } else {
+                Term::Constant(Cell::default(), Constant::Atom(clause_name!("true"), None))
+            };
+
+        Ok((query_terms, dynamic_clause_body))
     }
 
     fn setup_hook<'a, 'b, 'c>(
@@ -990,17 +1034,17 @@ impl RelationWorker {
         blocks_cuts: bool,
         assume_dyn: bool,
     ) -> Result<Rule, ParserError> {
-        let head = *terms.first().cloned().unwrap();
-        let post_head_terms: Vec<_> = terms.drain(1..).collect();
+        let dynamic_term_head = *terms.first().cloned().unwrap();
+        let post_head_terms: Vec<_> = terms.drain(1 ..).collect();
 
-        let tail = *post_head_terms.first().cloned().unwrap();
+        let (mut query_terms, dynamic_term_body) =
+            self.setup_query(indices, post_head_terms, blocks_cuts, assume_dyn)?;
 
         if assume_dyn {
-            self.dynamic_clauses.push((head, tail));
+            self.dynamic_clauses.push((dynamic_term_head, dynamic_term_body));
         }
 
-        let mut query_terms = self.setup_query(indices, post_head_terms, blocks_cuts)?;
-        let clauses = query_terms.drain(1..).collect();
+        let clauses = query_terms.drain(1 ..).collect();
         let qt = query_terms.pop().unwrap();
 
         match *terms.pop().unwrap() {
@@ -1022,11 +1066,14 @@ impl RelationWorker {
         terms: Vec<Box<Term>>,
         blocks_cuts: bool,
     ) -> Result<TopLevel, ParserError> {
-        Ok(TopLevel::Query(self.setup_query(
+        let (result, _) = self.setup_query(
             indices,
             terms,
             blocks_cuts,
-        )?))
+            false,
+        )?;
+
+        Ok(TopLevel::Query(result))
     }
 
     fn compact_module_scoped_head<'a, 'b, 'c>(
@@ -1141,6 +1188,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,
@@ -1243,7 +1291,7 @@ impl<'a> TopLevelBatchWorker<'a> {
         match self.dynamic_clause_map.get_mut(&(name.clone(), arity)) {
             Some(ref mut entry) => {
                 entry.clear(); // don't treat dynamic predicates as if they're discontiguous.
-                entry.extend(self.rel_worker.dynamic_clauses.drain(0..));
+                entry.extend(self.rel_worker.dynamic_clauses.drain(0 ..));
             }
             _ => {
                 self.rel_worker.dynamic_clauses.clear();

src/macros.rs

@@ -121,6 +121,9 @@ macro_rules! functor_term {
     (atom($e:expr), $arity:expr, $aux_lens:expr, $addendum: ident) => (
         HeapCellValue::Atom(clause_name!($e), None)
     );
+    (value($e:expr), $arity:expr, $aux_lens:expr, $addendum: ident) => (
+        $e
+    );
     (string($h:expr, $e:expr), $arity:expr, $aux_lens:expr, $addendum: ident) => ({
         let len: usize = $aux_lens.iter().sum();
         let h = len + $arity + 1 + $addendum.h() + $h;
@@ -150,9 +153,6 @@ macro_rules! from_constant {
             &Constant::Char(c) => {
                 HeapCellValue::Addr(Addr::Char(c))
             }
-            &Constant::CharCode(c) => {
-                HeapCellValue::Addr(Addr::CharCode(c))
-            }
             &Constant::Fixnum(n) => {
                 HeapCellValue::Addr(Addr::Fixnum(n))
             }
@@ -358,6 +358,7 @@ macro_rules! index_store {
             op_dir: $op_dir,
             modules: $modules,
             stream_aliases: StreamAliasDir::new(),
+            streams: StreamDir::new(),
         }
     };
 }
@@ -405,3 +406,26 @@ macro_rules! ar_reg {
         ArithmeticTerm::Reg($r)
     };
 }
+
+macro_rules! atom_from {
+    ($self:expr, $indices:expr, $e:expr) => {
+        match $e {
+            Addr::Con(h) if $self.heap.atom_at(h) => {
+                match &$self.heap[h] {
+                    HeapCellValue::Atom(ref atom, _) => {
+                        atom.clone()
+                    }
+                    _ => {
+                        unreachable!()
+                    }
+                }
+            }
+            Addr::Char(c) => {
+                clause_name!(c.to_string(), $indices.atom_tbl.clone())
+            }
+            _ => {
+                unreachable!()
+            }
+        }
+    }
+}

src/main.rs

@@ -1,33 +1,62 @@
+extern crate blake2;
+extern crate chrono;
+extern crate cpu_time;
 extern crate crossterm;
+extern crate divrem;
 #[macro_use]
 extern crate downcast;
 extern crate git_version;
+extern crate hostname;
 extern crate indexmap;
 #[macro_use]
 extern crate lazy_static;
 extern crate libc;
+extern crate native_tls;
 extern crate nix;
+extern crate openssl;
+extern crate ordered_float;
 #[macro_use]
 extern crate prolog_parser;
 #[macro_use]
 extern crate ref_thread_local;
+extern crate ring;
+extern crate ripemd160;
+extern crate rug;
+extern crate rustyline;
+extern crate sha3;
+extern crate unicode_reader;
 
-use git_version::git_version;
-use nix::sys::signal;
+use crate::nix::sys::signal;
 
-mod prolog;
+#[macro_use]
+mod macros;
+mod allocator;
+mod arithmetic;
+mod codegen;
+mod clause_types;
+mod debray_allocator;
+mod fixtures;
+mod forms;
+mod heap_iter;
+mod heap_print;
+mod indexing;
+mod instructions;
+mod iterators;
+mod machine;
+mod read;
+mod targets;
+mod write;
 
-use crate::prolog::machine::*;
-use crate::prolog::machine::streams::*;
-use crate::prolog::read::*;
+use machine::*;
+use machine::streams::*;
+use read::*;
 
-use std::env;
 use std::sync::atomic::Ordering;
 
 extern fn handle_sigint(signal: libc::c_int) {
     let signal = signal::Signal::from_c_int(signal).unwrap();
     if signal == signal::Signal::SIGINT {
-	INTERRUPT.store(true, Ordering::Relaxed);
+        INTERRUPT.store(true, Ordering::Relaxed);
     }
 }
 
@@ -35,11 +64,6 @@ fn main() {
     let handler = signal::SigHandler::Handler(handle_sigint);
     unsafe { signal::signal(signal::Signal::SIGINT, handler) }.unwrap();
 
-    if env::args().skip(1).any(|a| a == "-v" || a == "--version") {
-        println!("{:}", git_version!());
-        return;
-    }
-
     let mut wam = Machine::new(readline::input_stream(), Stream::stdout());
     wam.run_top_level();
 }