Merge pull request #338 from triska/master

also include a newline in portray_clause/1

.gitignore

@@ -1,4 +1,3 @@
 target/
-Cargo.lock
 
 

.travis.yml

@@ -11,3 +11,4 @@ matrix:
 script:
     - cargo build --verbose --all
     - cargo test --verbose --all
+    - cargo test --verbose --all --no-default-features --features num

Cargo.lock

@@ -0,0 +1,894 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "arc-swap"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "arrayref"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "arrayvec"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "autocfg"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "backtrace"
+version = "0.3.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "backtrace-sys 0.1.31 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-demangle 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "backtrace-sys"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cc 1.0.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "base64"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "blake2b_simd"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "arrayvec 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "constant_time_eq 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "cc"
+version = "1.0.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "cloudabi"
+version = "0.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "constant_time_eq"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "crossterm"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "crossterm_winapi 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+ "mio 0.6.21 (registry+https://github.com/rust-lang/crates.io-index)",
+ "parking_lot 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "signal-hook 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "crossterm_winapi"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "dirs"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "dirs-sys 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+ "redox_users 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "downcast"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "failure"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "backtrace 0.3.35 (registry+https://github.com/rust-lang/crates.io-index)",
+ "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "failure_derive"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.44 (registry+https://github.com/rust-lang/crates.io-index)",
+ "synstructure 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "fuchsia-cprng"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "fuchsia-zircon"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "fuchsia-zircon-sys"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "git-version"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "git-version-macro 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "proc-macro-hack 0.5.14 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "git-version-macro"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro-hack 0.5.14 (registry+https://github.com/rust-lang/crates.io-index)",
+ "proc-macro2 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 1.0.17 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "gmp-mpfr-sys"
+version = "1.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "dirs 2.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "iovec"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "kernel32-sys"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "lexical"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lexical-core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "lexical-core"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "stackvector 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "static_assertions 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.62"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "lock_api"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "scopeguard 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "log"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "maybe-uninit"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "memchr"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "mio"
+version = "0.6.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "miow 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)",
+ "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "miow"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ws2_32-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "net2"
+version = "0.2.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "nix"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+ "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "nix"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+ "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "nodrop"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "num-bigint"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "autocfg 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-integer 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-traits 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "autocfg 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-traits 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "autocfg 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-bigint 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-integer 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-traits 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "num-rug-adapter"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-bigint 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-integer 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-rational 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-traits 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.1.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "num-traits 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "autocfg 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "ordered-float"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "lock_api 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "parking_lot_core 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+ "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
+ "smallvec 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "proc-macro-hack"
+version = "0.5.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "proc-macro2"
+version = "0.4.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "unicode-xid 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "prolog_parser"
+version = "0.8.49"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "lexical 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-rug-adapter 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ordered-float 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rug 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode_reader 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "quote"
+version = "0.6.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "rand_os"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "rdrand"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.1.51"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "redox_users"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rust-argon2 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "ref_thread_local"
+version = "0.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "rug"
+version = "1.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "gmp-mpfr-sys 1.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "rust-argon2"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "blake2b_simd 0.5.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "crossbeam-utils 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "rustyline"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "dirs 2.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "nix 0.14.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-segmentation 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-width 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "utf8parse 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "ryu"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "scopeguard"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "scryer-prolog"
+version = "0.8.118"
+dependencies = [
+ "crossterm 0.16.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "dirs 2.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "downcast 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "git-version 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "indexmap 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+ "nix 0.15.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-rug-adapter 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ordered-float 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "prolog_parser 0.8.49 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ref_thread_local 0.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rug 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustyline 6.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "signal-hook"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+ "mio 0.6.21 (registry+https://github.com/rust-lang/crates.io-index)",
+ "signal-hook-registry 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "arc-swap 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "smallvec"
+version = "0.6.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "maybe-uninit 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "stackvector"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "static_assertions"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "syn"
+version = "0.15.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-xid 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.44 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "unicode-xid"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "unicode_reader"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "smallvec 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-segmentation 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "unreachable"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "utf8parse"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "void"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winapi"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winapi"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "winapi-build"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "ws2_32-sys"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[metadata]
+"checksum arc-swap 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "d7b8a9123b8027467bce0099fe556c628a53c8d83df0507084c31e9ba2e39aff"
+"checksum arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0d382e583f07208808f6b1249e60848879ba3543f57c32277bf52d69c2f0f0ee"
+"checksum arrayvec 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "b8d73f9beda665eaa98ab9e4f7442bd4e7de6652587de55b2525e52e29c1b0ba"
+"checksum autocfg 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1d49d90015b3c36167a20fe2810c5cd875ad504b39cff3d4eae7977e6b7c1cb2"
+"checksum backtrace 0.3.35 (registry+https://github.com/rust-lang/crates.io-index)" = "1371048253fa3bac6704bfd6bbfc922ee9bdcee8881330d40f308b81cc5adc55"
+"checksum backtrace-sys 0.1.31 (registry+https://github.com/rust-lang/crates.io-index)" = "82a830b4ef2d1124a711c71d263c5abdc710ef8e907bd508c88be475cebc422b"
+"checksum base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0b25d992356d2eb0ed82172f5248873db5560c4721f564b13cb5193bda5e668e"
+"checksum bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
+"checksum blake2b_simd 0.5.7 (registry+https://github.com/rust-lang/crates.io-index)" = "bf775a81bb2d464e20ff170ac20316c7b08a43d11dbc72f0f82e8e8d3d6d0499"
+"checksum byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a7c3dd8985a7111efc5c80b44e23ecdd8c007de8ade3b96595387e812b957cf5"
+"checksum cc 1.0.41 (registry+https://github.com/rust-lang/crates.io-index)" = "8dae9c4b8fedcae85592ba623c4fd08cfdab3e3b72d6df780c6ead964a69bfff"
+"checksum cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+"checksum cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
+"checksum constant_time_eq 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "995a44c877f9212528ccc74b21a232f66ad69001e40ede5bcee2ac9ef2657120"
+"checksum crossbeam-utils 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "04973fa96e96579258a5091af6003abde64af786b860f18622b82e026cca60e6"
+"checksum crossterm 0.16.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b8a3223215bc00c666d6be730e88aef245ad4a4f837e87a16c347e8acf701643"
+"checksum crossterm_winapi 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "057b7146d02fb50175fd7dbe5158f6097f33d02831f43b4ee8ae4ddf67b68f5c"
+"checksum dirs 2.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "13aea89a5c93364a98e9b37b2fa237effbb694d5cfe01c5b70941f7eb087d5e3"
+"checksum dirs-sys 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "afa0b23de8fd801745c471deffa6e12d248f962c9fd4b4c33787b055599bde7b"
+"checksum downcast 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4bb454f0228b18c7f4c3b0ebbee346ed9c52e7443b0999cd543ff3571205701d"
+"checksum failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "795bd83d3abeb9220f257e597aa0080a508b27533824adf336529648f6abf7e2"
+"checksum failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "ea1063915fd7ef4309e222a5a07cf9c319fb9c7836b1f89b85458672dbb127e1"
+"checksum fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
+"checksum fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
+"checksum fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
+"checksum git-version 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "94918e83f1e01dedc2e361d00ce9487b14c58c7f40bab148026fa39d42cb41e2"
+"checksum git-version-macro 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "34a97a52fdee1870a34fa6e4b77570cba531b27d1838874fef4429a791a3d657"
+"checksum gmp-mpfr-sys 1.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "72592cd7513feefa5e41414825c42e839120d2f09e10c6094105d066072955fb"
+"checksum indexmap 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a4d6d89e0948bf10c08b9ecc8ac5b83f07f857ebe2c0cbe38de15b4e4f510356"
+"checksum iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
+"checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
+"checksum lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+"checksum lexical 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c106ed999697325a540c43d66a8d5175668cd96d7eb0bdba03a3bd98256cd698"
+"checksum lexical-core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3e82e023e062f1d25f807ad182008fba1b46538e999f908a08cc0c29e084462e"
+"checksum libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)" = "34fcd2c08d2f832f376f4173a231990fa5aef4e99fb569867318a227ef4c06ba"
+"checksum lock_api 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "79b2de95ecb4691949fea4716ca53cdbcfccb2c612e19644a8bad05edcf9f47b"
+"checksum log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7"
+"checksum maybe-uninit 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00"
+"checksum memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "88579771288728879b57485cc7d6b07d648c9f0141eb955f8ab7f9d45394468e"
+"checksum mio 0.6.21 (registry+https://github.com/rust-lang/crates.io-index)" = "302dec22bcf6bae6dfb69c647187f4b4d0fb6f535521f7bc022430ce8e12008f"
+"checksum miow 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8c1f2f3b1cf331de6896aabf6e9d55dca90356cc9960cca7eaaf408a355ae919"
+"checksum net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)" = "42550d9fb7b6684a6d404d9fa7250c2eb2646df731d1c06afc06dcee9e1bcf88"
+"checksum nix 0.14.1 (registry+https://github.com/rust-lang/crates.io-index)" = "6c722bee1037d430d0f8e687bbdbf222f27cc6e4e68d5caf630857bb2b6dbdce"
+"checksum nix 0.15.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3b2e0b4f3320ed72aaedb9a5ac838690a8047c7b275da22711fddff4f8a14229"
+"checksum nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "2f9667ddcc6cc8a43afc9b7917599d7216aa09c463919ea32c59ed6cac8bc945"
+"checksum num-bigint 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f9c3f34cdd24f334cb265d9bf8bfa8a241920d026916785747a92f0e55541a1a"
+"checksum num-integer 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)" = "b85e541ef8255f6cf42bbfe4ef361305c6c135d10919ecc26126c4e5ae94bc09"
+"checksum num-rational 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f2885278d5fe2adc2f75ced642d52d879bffaceb5a2e0b1d4309ffdfb239b454"
+"checksum num-rug-adapter 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3ab3f405f69d14cdcf0ca44599eb074093633a53ec3d402be0bf1e57709c7502"
+"checksum num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "92e5113e9fd4cc14ded8e499429f396a20f98c772a47cc8622a736e1ec843c31"
+"checksum num-traits 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)" = "443c53b3c3531dfcbfa499d8893944db78474ad7a1d87fa2d94d1a2231693ac6"
+"checksum ordered-float 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7eb5259643245d3f292c7a146b2df53bba24d7eab159410e648eb73dc164669d"
+"checksum parking_lot 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "92e98c49ab0b7ce5b222f2cc9193fc4efe11c6d0bd4f648e374684a6857b1cfc"
+"checksum parking_lot_core 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7582838484df45743c8434fbff785e8edf260c28748353d44bc0da32e0ceabf1"
+"checksum proc-macro-hack 0.5.14 (registry+https://github.com/rust-lang/crates.io-index)" = "fcfdefadc3d57ca21cf17990a28ef4c0f7c61383a28cb7604cf4a18e6ede1420"
+"checksum proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)" = "cf3d2011ab5c909338f7887f4fc896d35932e29146c12c8d01da6b22a80ba759"
+"checksum proc-macro2 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)" = "6c09721c6781493a2a492a96b5a5bf19b65917fe6728884e7c44dd0c60ca3435"
+"checksum prolog_parser 0.8.49 (registry+https://github.com/rust-lang/crates.io-index)" = "82f46113e58039861f82f6b6cdaca94c0997eda2c7317a4c4f13d549c4601eec"
+"checksum quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)" = "6ce23b6b870e8f94f81fb0a363d65d86675884b34a09043c81e5562f11c1f8e1"
+"checksum quote 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2bdc6c187c65bca4260c9011c9e3132efe4909da44726bad24cf7572ae338d7f"
+"checksum rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
+"checksum rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
+"checksum rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
+"checksum rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
+"checksum redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)" = "423e376fffca3dfa06c9e9790a9ccd282fafb3cc6e6397d01dbf64f9bacc6b85"
+"checksum redox_users 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4ecedbca3bf205f8d8f5c2b44d83cd0690e39ee84b951ed649e9f1841132b66d"
+"checksum ref_thread_local 0.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d813022b2e00774a48eaf43caaa3c20b45f040ba8cbf398e2e8911a06668dbe6"
+"checksum rug 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "592f3a1bba452fcfb91127354012c2b3aa580b266caef1923b16638057c038b5"
+"checksum rust-argon2 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4ca4eaef519b494d1f2848fc602d18816fed808a981aedf4f1f00ceb7c9d32cf"
+"checksum rustc-demangle 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "4c691c0e608126e00913e33f0ccf3727d5fc84573623b8d65b2df340b5201783"
+"checksum rustyline 6.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "de64be8eecbe428b6924f1d8430369a01719fbb182c26fa431ddbb0a95f5315d"
+"checksum ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "eb9e9b8cde282a9fe6a42dd4681319bfb63f121b8a8ee9439c6f4107e58a46f7"
+"checksum scopeguard 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+"checksum signal-hook 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "10b9f3a1686a29f53cfd91ee5e3db3c12313ec02d33765f02c1a9645a1811e2c"
+"checksum signal-hook-registry 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "94f478ede9f64724c5d173d7bb56099ec3e2d9fc2774aac65d34b8b890405f41"
+"checksum slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
+"checksum smallvec 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)" = "f7b0758c52e15a8b5e3691eae6cc559f08eee9406e548a4477ba4e67770a82b6"
+"checksum smallvec 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5c2fb2ec9bcd216a5b0d0ccf31ab17b5ed1d627960edff65bbe95d3ce221cefc"
+"checksum stackvector 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c049c77bf85fbc036484c97b008276d539d9ebff9dfbde37b632ebcd5b8746b6"
+"checksum static_assertions 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "c19be23126415861cb3a23e501d34a708f7f9b2183c5252d690941c2e69199d5"
+"checksum syn 0.15.44 (registry+https://github.com/rust-lang/crates.io-index)" = "9ca4b3b69a77cbe1ffc9e198781b7acb0c7365a883670e8f1c1bc66fba79a5c5"
+"checksum syn 1.0.17 (registry+https://github.com/rust-lang/crates.io-index)" = "0df0eb663f387145cab623dea85b09c2c5b4b0aef44e945d928e682fce71bb03"
+"checksum synstructure 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)" = "02353edf96d6e4dc81aea2d8490a7e9db177bf8acb0e951c24940bf866cb313f"
+"checksum unicode-segmentation 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1967f4cdfc355b37fd76d2a954fb2ed3871034eb4f26d60537d88795cfc332a9"
+"checksum unicode-width 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "7007dbd421b92cc6e28410fe7362e2e0a2503394908f417b68ec8d1c364c4e20"
+"checksum unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc"
+"checksum unicode-xid 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c"
+"checksum unicode_reader 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f886d405a2be65db804cb1088f969dbd99528a9eec9bcf941584b17de4cd3034"
+"checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
+"checksum utf8parse 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8772a4ccbb4e89959023bc5b7cb8623a795caa7092d99f3aa9501b9484d4557d"
+"checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
+"checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
+"checksum winapi 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)" = "8093091eeb260906a183e6ae1abdba2ef5ef2257a21801128899c3fc699229c6"
+"checksum winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
+"checksum winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+"checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+"checksum ws2_32-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "scryer-prolog"
-version = "0.8.112"
+version = "0.8.118"
 authors = ["Mark Thom <markjordanthom@gmail.com>"]
 build = "build.rs"
 repository = "https://github.com/mthom/scryer-prolog"
@@ -11,18 +11,22 @@ edition = "2018"
 [build-dependencies]
 indexmap = "1.0.2"
 
+[features]
+default = ["rug", "prolog_parser/rug"]
+num = ["num-rug-adapter", "prolog_parser/num"]
+
 [dependencies]
+crossterm = "0.16.0"
 dirs = "2.0.2"
 downcast = "0.10.0"
+git-version = "0.3.4"
 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" }
 ordered-float = "0.5.0"
-prolog_parser = "0.8.33"
+prolog_parser = { version = "0.8.49", default-features = false }
 ref_thread_local = "0.0.0"
-rug = "1.4.0"
-rustyline = "5.0.3"
-
-[dependencies.termion]
-version = "1.4.0"
+rug = { version = "1.4.0", optional = true }
+rustyline = "6.0.0"

README.md

@@ -30,10 +30,8 @@ Extend Scryer Prolog to include the following, among other features:
 - [x] Built-in predicates for list processing and top-level declarative
       control (`setup_call_cleanup/3`, `call_with_inference_limit/3`,
       etc.)
-- [x] Default representation of strings as list of chars, using a packed
-      internal representation.
-        - A representation of 'partial strings' as difference lists
-          of characters.
+- [x] ~~Default representation of strings as lists of characters, using a packed
+      internal representation.~~
 - [x] `term_expansion/2` and `goal_expansion/2`.
 - [x] Definite Clause Grammars.
 - [x] Attributed variables using the SICStus Prolog interface and
@@ -50,11 +48,17 @@ Extend Scryer Prolog to include the following, among other features:
 - [x] Backtrackable and non-backtrackable global variables via `bb_get/2`
       `bb_put/2` (non-backtrackable) and `bb_b_put/2`
       (backtrackable).
+- [x] Delimited continuations based on reset/3, shift/1 (documented in
+      "Delimited Continuations for Prolog").
+- [x] Tabling library based on delimited continuations
+      (documented in "Tabling as a Library with Delimited Control").
+- [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_).
-- [ ] An incremental compacting garbage collector satisfying the five
+- [ ] A compacting garbage collector satisfying the five
       properties of "Precise Garbage Collection in Prolog."
 - [ ] Mode declarations.
-- [ ] Extensions for clp(FD).
 
 ## Phase 3
 
@@ -79,154 +83,45 @@ Programming?"
 unum implementation or an ad hoc one. Unums are described in
 Gustafson's book "The End of Error."
 
-3. Add support for shift/reset delimited continuations, see "Delimited
-Continuations for Prolog."
-
-4. Add concurrent tables to manage shared references to atoms and
+3. Add concurrent tables to manage shared references to atoms and
 strings.
 
-5. Add optional SLG resolution for fast memoization of predicates.
-
-6. Add some form of JIT predicate indexing.
+4. Add some form of JIT predicate indexing.
 
 ## Installing Scryer Prolog
 
 First, install the latest stable version of
 [Rust](https://www.rust-lang.org/en-US/install.html) using your
-preferred method. Then install the latest Scryer Prolog with cargo,
-like so:
+preferred method. Scryer tends to use features from newer Rust
+releases, whereas Rust packages in Linux distributions, Macports,
+etc. tend to lag behind. [rustup](http://rustup.rs) will keep your
+Rust updated to the latest stable release; any existing Rust
+distribution should be uninstalled from your system before rustup is
+used.
+
+Scryer Prolog can be installed with cargo, like so:
 
 ```
 $> cargo install scryer-prolog
 ```
 
 cargo will download and install the libraries Scryer Prolog uses
-automatically. You can find the `scryer-prolog` executable in
-`~/.cargo/bin`.
+automatically from crates.io. You can find the `scryer-prolog`
+executable in `~/.cargo/bin`.
 
-Note on compatibility: Scryer Prolog should work on Linux, Mac OS X,
-and BSD variants on which Rust runs. Windows support hinges on
-rustyline and Termion being functional in that environment, which to
-my knowledge is not currently the case.
+Publishing Rust crates to crates.io and pushing to git are entirely
+distinct, independent processes, so to be sure you have the latest
+commit, it is recommended to clone directly from this git repository,
+which can be done as follows:
 
-## Built-in predicates
+```
+$> git clone https://github.com/mthom/scryer-prolog
+$> cd scryer-prolog
+$> cargo run [--release]
+```
 
-The following predicates are built-in to Scryer.
-
-* Arithmetic support:
-    * `is/2` works for `(+)/{1,2}`, `(-)/{1,2}`, `(*)/2`, `(//)/2`, `(**)/2`,
-      `(^)/2`, `(div)/2`, `(/)/2`, `(rdiv)/2`, `(xor)/2`, `(rem)/2`,
-      `(mod)/2`, `(/\)/2`, `(\/)/2`, `(>>)/2`,`(<<)/2`, `(\)/1`,
-      `abs/1`, `sin/1`, `cos/1`, `tan/1`, `asin/1`, `acos/1`,
-      `atan/1`, `atan2/2`, `log/1`, `exp/1`, `sqrt/1`, `float/1`,
-      `truncate/1`, `round/1`, `floor/1`, `ceiling/1`, `pi/0`,
-      `min/1`, `max/1`      
-    * Comparison operators: `>`, `<`, `=<`, `>=`, `=:=`, `=\=`.
-* `(:)/2`
-* `(@>)/2`
-* `(@>=)/2`
-* `(@=<)/2`
-* `(@<)/2`
-* `(\+)/1`
-* `(==)/2`
-* `(\==)/2`
-* `(=)/2`
-* `(\=)/2`
-* `(=..)/2`
-* `(->)/2`
-* `(;)/2`
-* `abolish/1`
-* `acyclic_term/2`
-* `append/3`
-* `arg/3`
-* `asserta/1`
-* `assertz/1`
-* `atom/1`
-* `atomic/1`
-* `atom_chars/2`
-* `atom_codes/2`
-* `atom_concat/3`
-* `atom_length/2`
-* `bagof/3`
-* `bb_b_put/2`
-* `bb_get/2`
-* `bb_put/2`
-* `between/3`
-* `call/1..62`
-* `call_cleanup/2`
-* `call_with_inference_limit/3`
-* `call_residue_vars/2`
-* `can_be/2`
-* `catch/3`
-* `clause/2`
-* `compare/3`
-* `compound/1`
-* `copy_term/2`
-* `current_predicate/1`
-* `current_op/3`
-* `cyclic_term/1`
-* `dif/2`
-* `expand_goal/2`
-* `expand_term/2`
-* `fail/0`
-* `false/0`
-* `findall/{3,4}`
-* `float/1`
-* `forall/2`
-* `freeze/2`
-* `functor/3`
-* `gen_int/1`
-* `gen_nat/1`
-* `get_char/1`
-* `goal_expansion/2`
-* `ground/1`
-* `halt/0`
-* `integer/1`
-* `is_list/1`
-* `is_partial_string/1`
-* `keysort/2`
-* `length/2`
-* `maplist/2..9`
-* `member/2`
-* `memberchk/2`
-* `must_be/2`
-* `nl/0`
-* `nonvar/1`
-* `number_chars/2`
-* `number_codes/2`
-* `numbervars/2`
-* `numlist/{2,3}`
-* `once/1`
-* `op/3`
-* `partial_string/2`
-* `phrase/{2,3}`
-* `rational/1`
-* `read/1`
-* `repeat/{0,1}`
-* `retract/1`
-* `reverse/2`
-* `select/3`
-* `setof/3`
-* `setup_call_cleanup/3`
-* `sort/2`
-* `string/1`
-* `sub_atom/5`
-* `subsumes_term/2`
-* `term_expansion/2`
-* `term_variables/2`
-* `throw/1`
-* `true/0`
-* `unify_with_occurs_check/2`
-* `use_module/{1,2}`
-* `user:goal_expansion/2`
-* `user:term_expansion/2`
-* `var/1`
-* `variant/2`
-* `wam_instructions/2`
-* `write/1`
-* `write_canonical/1`
-* `writeq/1`
-* `write_term/2`
+The optional `--release` flag will perform various optimizations,
+producing a faster executable.
 
 ## Tutorial
 To enter a multi-clause predicate, the directive "[user]" is used.
@@ -261,11 +156,10 @@ Wildcards work as well:
 member(X, [X|_]).
 member(X, [_|Xs]) :- member(X, Xs).
 ?- member(X, [a, b, c]).
-true .
-X = a ;
-X = b ;
-X = c ;
-false.
+   X = a
+;  X = b
+;  X = c
+;  false.
 ```
 and so do conjunctive queries:
 ```
@@ -275,21 +169,15 @@ f(X) :- g(X).
 g(x). g(y). g(z).
 h(call(f, X)).
 ?- h(X), X.
-true .
-X = call(f, x) ;
-X = call(f, y) ;
-X = call(f, z).
+   X = call(f,x)
+;  X = call(f,y)
+;  X = call(f,z).
 ```
 
 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).
 
-To clear the database, type
-```
-?- [clear].
-```
-
 To quit scryer-prolog, type
 ```
 ?- halt.
@@ -301,42 +189,128 @@ Scryer supports dynamic operators. Using the built-in
 arithmetic operators with the usual precedences,
 
 ```
-?- write_canonical(-5 + 3 - (2 * 4) // 8).
--(+(-(5), 3), //(*(2, 4), 8))
+?- write_canonical(-5 + 3 - (2 * 4) // 8), nl.
+   -(+(-5,3),//(*(2,4),8))
 true.
 ```
 
 New operators can be defined using the `op` declaration.
 
-### Partial strings
+### Strings and partial strings
 
-Scryer has two specialized, non-ISO builtin predicates for handling
-so-called "partial strings". Partial strings imitate difference lists
-of characters, but are much more space efficient. This efficiency
-comes at the cost of full generality -- you cannot unify the tail
-variables of two distinct partial strings, because their buffers will
-always be distinct.
+In Scryer Prolog, the default value of the Prolog flag `double_quotes`
+is `chars`, which is also the recommended setting. This means that
+double-quoted strings are interpreted as lists of *characters*, in the
+tradition of Marseille&nbsp;Prolog.
 
-If `X` is a free variable, the query
+For example, the following query succeeds:
 
-`?- partial_string("abc", X), X = [a, b, c | Y], is_partial_string(X),
-is_partial_string(Y).`
+```
+?- "abc" = [a,b,c].
+   true.
+```
 
-will succeed. Further, if `Y` a free variable, unifying `Y` against
-another string, "def" in this case, produces the equations
+Internally, strings are represented very compactly in packed
+UTF-8&nbsp;encoding. A naive representation of strings as lists of
+characters would use one memory&nbsp;cell per character, one
+memory&nbsp;cell per list constructor, and one memory&nbsp;cell for
+each tail that occurs in the list. Since one memory&nbsp;cell takes
+8&nbsp;bytes on 64-bit machines, the packed representation used by
+Scryer&nbsp;Prolog yields an up&nbsp;to **24-fold&nbsp;reduction** of
+memory usage, and corresponding reduction of memory&nbsp;accesses when
+creating and processing strings.
 
-`X = [a, b, c, d, e, f], Y = [d, e, f].`
+Scryer Prolog uses the same efficient encoding for *partial* strings,
+which appear to Prolog code as partial lists of characters. The
+predicate `partial_string/3` from `library(iso_ext)` lets you
+construct partial&nbsp;strings explicitly. For example:
+
+```
+?- partial_string("abc", Ls0, Ls).
+   Ls0 = [a,b,c|Ls].
+```
+
+In this case, and as the answer illustrates, `Ls0` is
+indistinguishable from a partial&nbsp;list with tail&nbsp;`Ls`, while
+the efficient packed representation is used internally.
+
+An important design goal of Scryer Prolog is to *automatically* use
+the efficient string representation whenever possible. Therefore, it
+is only very rarely necessary to use `partial_string/3` explicitly. In
+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.
 
 ### 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` for
+predicates and operators. See the files
+[`src/prolog/lib/*.pl`](src/prolog/lib) for
 examples.
 
-At the time of this writing, several control and list processing
-operators and predicates are hidden in their own modules that have not
-been exported to the toplevel. To export them, write
+At the time of this writing, many predicates reside in their own
+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)
+  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)
+  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)
+  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)
+  providing `if_/3`, `tfilter/3` and related predicates
+  as described in *Indexing&nbsp;dif/2*.
+* [`clpz`](src/prolog/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)
+  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)
+  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.
+  They are declarative replacements for logically flawed
+  lower-level type tests. For instance, instead of `integer(X)`,
+  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)
+  The operator `(table)/1` is used in directives that prepare
+  predicates for tabled execution (SLG&nbsp;resolution).
+* [`format`](src/prolog/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)
+  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)
+  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.
+
+To use predicates provided by the `lists` library, write:
 
 ```
 ?- use_module(library(lists)).
@@ -379,4 +353,4 @@ 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.
+the end of the stream.

build.rs

@@ -52,5 +52,9 @@ fn main()
     }
 
     libraries.write_all(b"\n\n        m\n    };
-}").unwrap();
+}\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();
 }

src/l0/ast.rs

@@ -1,51 +0,0 @@
-use std::cell::{Cell};
-use std::vec::{Vec};
-
-pub type Var = String;
-
-pub type Atom = String;
-
-#[derive(Debug)]
-pub enum TopLevel {
-    Fact(Term),
-    Query(Term)
-}
-
-#[derive(Debug)]
-pub enum Term {
-    Atom(Cell<usize>, Atom),
-    Clause(Cell<usize>, Atom, Vec<Box<Term>>),
-    Var(Cell<usize>, Var)
-}
-
-pub enum FactInstruction {
-    GetStructure(Atom, usize, usize),
-    UnifyVariable(usize),
-    UnifyValue(usize)
-}
-
-pub enum QueryInstruction {    
-    PutStructure(Atom, usize, usize),
-    SetVariable(usize),
-    SetValue(usize),    
-}
-
-pub type CompiledFact = Vec<FactInstruction>;
-
-pub type CompiledQuery = Vec<QueryInstruction>;
-
-#[derive(Clone, Copy, PartialEq)]
-pub enum Addr {
-    HeapCell(usize),
-    RegNum(usize)
-}
-
-impl Term {
-    pub fn set_cell(&self, cell_num: usize) {
-        match self {
-            &Term::Atom(ref cell, _) => cell.set(cell_num),
-            &Term::Clause(ref cell, _, _) => cell.set(cell_num),
-            &Term::Var(ref cell, _) => cell.set(cell_num)
-        };
-    }
-}

src/l0/codegen.rs

@@ -1,126 +0,0 @@
-use l0::ast::{Atom, Term, FactInstruction, QueryInstruction, Var};
-use l0::iterators::{BreadthFirstIterator, PostOrderIterator};
-
-use std::collections::{HashSet};
-use std::fmt;
-use std::vec::{Vec};
-
-impl fmt::Display for QueryInstruction {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &QueryInstruction::PutStructure(ref a, ref s, ref r) =>
-                write!(f, "put_structure {}/{}, X{}", a, s, r),
-            &QueryInstruction::SetVariable(ref r) =>
-                write!(f, "set_variable X{}", r),
-            &QueryInstruction::SetValue(ref r) =>
-                write!(f, "set_value X{}", r),
-        }
-    }
-}
-
-impl fmt::Display for FactInstruction {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &FactInstruction::GetStructure(ref a, ref s, ref r) =>
-                write!(f, "get_structure {}/{}, X{}", a, s, r),
-            &FactInstruction::UnifyVariable(ref r) =>
-                write!(f, "unify_variable X{}", r),
-            &FactInstruction::UnifyValue(ref r) =>
-                write!(f, "unify_value X{}", r)
-        }
-    }
-}
-
-pub trait CompilationTarget<'a> {
-    type Iterator : Iterator<Item=&'a Term>;
-    
-    fn iter(term: &'a Term) -> Self::Iterator;
-
-    fn to_structure(name: Atom, arity: usize, cell_num: usize) -> Self;
-    fn to_value(cell_num: usize) -> Self;
-    fn to_variable(cell_num: usize) -> Self;
-}
-
-impl<'a> CompilationTarget<'a> for FactInstruction {
-    type Iterator = BreadthFirstIterator<'a>;
-    
-    fn iter(term: &'a Term) -> Self::Iterator {
-        term.breadth_first_iter()
-    }
-
-    fn to_structure(name: Atom, arity: usize, cell_num: usize) -> Self {
-        FactInstruction::GetStructure(name, arity, cell_num)
-    }
-
-    fn to_value(cell_num: usize) -> Self {
-        FactInstruction::UnifyValue(cell_num)
-    }
-
-    fn to_variable(cell_num: usize) -> Self {
-        FactInstruction::UnifyVariable(cell_num)
-    }
-}
-
-impl<'a> CompilationTarget<'a> for QueryInstruction {
-    type Iterator = PostOrderIterator<'a>;
-
-    fn iter(term: &'a Term) -> Self::Iterator {
-        term.post_order_iter()
-    }
-
-    fn to_structure(name: Atom, arity: usize, cell_num: usize) -> Self {
-        QueryInstruction::PutStructure(name, arity, cell_num)
-    }
-
-    fn to_value(cell_num: usize) -> Self {
-        QueryInstruction::SetValue(cell_num)
-    }
-
-    fn to_variable(cell_num: usize) -> Self {
-        QueryInstruction::SetVariable(cell_num)
-    }
-}
-
-fn subterm_to_instr<'a, Target>(subterm:  &'a Term,
-                                bindings: &mut HashSet<&'a Var>)
-                                -> Target
-    where Target: CompilationTarget<'a>
-{
-    match subterm {
-        &Term::Atom(ref cell_num, _) =>
-            Target::to_value(cell_num.get()),
-        &Term::Var(ref cell_num, ref atom) if bindings.contains(atom) =>
-            Target::to_value(cell_num.get()),
-        &Term::Var(ref cell_num, ref atom) => {
-            bindings.insert(atom);
-            Target::to_variable(cell_num.get())
-        },
-        &Term::Clause(ref cell_num, _, _) =>
-            Target::to_value(cell_num.get())
-    }
-}
-
-pub fn compile_target<'a, Target>(term: &'a Term) -> Vec<Target>
-    where Target: CompilationTarget<'a>
-{
-    let mut iter     = Target::iter(term);
-    let mut target   = Vec::<Target>::new();
-    let mut bindings = HashSet::new();
-
-    while let Some(term) = iter.next() {
-        match term {
-            &Term::Atom(ref cell_num, ref atom) =>
-                target.push(Target::to_structure(atom.clone(), 0, cell_num.get())),
-            &Term::Clause(ref cell_num, ref atom, ref terms) => {
-                target.push(Target::to_structure(atom.clone(), 0, cell_num.get()));
-
-                for subterm in terms {
-                    target.push(subterm_to_instr(subterm.as_ref(), &mut bindings));
-                }
-            },
-            _ => {},
-        };
-    }
-
-    target
-}

src/l0/iterators.rs

@@ -1,98 +0,0 @@
-use l0::ast::{Term};
-
-use std::collections::{VecDeque};
-use std::vec::{Vec};
-
-enum DepthFirstIteratorState<'a> {        
-    // child no., the containing clause, its vector.
-    Clause(usize, &'a Term, &'a Vec<Box<Term>>),
-    NonClause(&'a Term)
-}
-
-pub struct PostOrderIterator<'a> {
-    state_stack: Vec<DepthFirstIteratorState<'a>>        
-}
-
-impl<'a> PostOrderIterator<'a> {
-    fn push_clause(&mut self,
-                   child_num: usize,
-                   term: &'a Term,
-                   child_terms: &'a Vec<Box<Term>>)
-    {
-        self.state_stack.push(DepthFirstIteratorState::Clause(child_num,
-                                                              term,
-                                                              child_terms));
-    }
-
-    fn render_new_state(term: &'a Term) -> DepthFirstIteratorState<'a> {
-        match term {
-            &Term::Clause(_, _, ref child_terms) =>
-                DepthFirstIteratorState::Clause(0, term, child_terms),
-            _ => DepthFirstIteratorState::NonClause(term)
-        }
-    }
-
-    fn push_term(&mut self, term: &'a Term) {
-        self.state_stack.push(Self::render_new_state(term));
-    }
-}
-
-impl<'a> Iterator for PostOrderIterator<'a> {
-    type Item = &'a Term;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        while let Some(iter_state) = self.state_stack.pop() {
-            match iter_state {
-                DepthFirstIteratorState::Clause(child_num, term, child_terms) => {                    
-                    if child_num == child_terms.len() {
-                        return Some(term);
-                    } else {
-                        self.push_clause(child_num + 1, term, child_terms);
-                        self.push_term(child_terms[child_num].as_ref());
-                    }
-                },
-                DepthFirstIteratorState::NonClause(term) => return Some(term),
-            };
-        }
-
-        None
-    }
-}
-
-pub struct BreadthFirstIterator<'a> {
-    state_queue : VecDeque<&'a Term>
-}
-
-impl<'a> Iterator for BreadthFirstIterator<'a> {
-    type Item = &'a Term;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if let Some(term) = self.state_queue.pop_front() {            
-            if let &Term::Clause(_, _, ref child_terms) = term {
-                for term in child_terms {
-                    self.state_queue.push_back(term);
-                }
-
-                return Some(term);
-            }
-
-            return Some(term);
-        }
-
-        None
-    }
-}
-    
-impl<'a> Term {
-    pub fn post_order_iter(&'a self) -> PostOrderIterator<'a> {
-        let initial_state = PostOrderIterator::render_new_state(self);
-        PostOrderIterator { state_stack: vec![initial_state] }
-    }
-
-    pub fn breadth_first_iter(&'a self) -> BreadthFirstIterator<'a> {
-        let mut queue = VecDeque::new();
-        queue.push_back(self);
-        
-        BreadthFirstIterator { state_queue: queue }
-    }
-}

src/l0/l0_parser.lalrpop

@@ -1,31 +0,0 @@
-use std::cell::{Cell};
-use l0::ast::{Atom, Term, TopLevel, Var};
-
-grammar;
-
-pub TopLevel: TopLevel = {
-    "?-" <t:Term> "." => TopLevel::Query(t),
-    <t:Term> "."      => TopLevel::Fact(t),
-};
-
-Atom : Atom = {
-     r"[a-z][a-z0-9_]*" => <>.trim().to_string(),
-};
-
-Var : Var = {
-     r"[A-Z][a-z0-9_]*" => <>.trim().to_string(),
-};	
-
-BoxedTerm : Box<Term> = {
-     <t:Term> => Box::new(t),
-};
-
-Term : Term = {
-     <a:Atom> "(" <ts: (<BoxedTerm> ",")*> <t:BoxedTerm> ")" => {
-     	      let mut ts = ts;
-     	      ts.push(t);
-	      Term::Clause(Cell::new(0), a, ts)
-     },
-     <Atom> => Term::Atom(Cell::new(0), <>),
-     <Var>  => Term::Var(Cell::new(0), <>),
-};

src/l0/machine.rs

@@ -1,238 +0,0 @@
-use l0::ast::{Addr, Atom, CompiledFact, FactInstruction, QueryInstruction};
-
-use std::vec::{Vec};
-
-#[derive(Clone)]
-enum HeapCell {
-    NamedStr(usize, Atom),
-    Ref(usize),
-    Str(usize),
-}
-
-#[derive(Clone, Copy)]
-enum MachineMode {
-    Read,
-    Write
-}
-
-type Heap = Vec<HeapCell>;
-
-type Registers = Vec<HeapCell>;
-
-pub struct Machine {
-    h : usize,
-    s : usize,
-    pub fail : bool,
-    heap : Heap,
-    mode : MachineMode,
-    pub program : Option<CompiledFact>,
-    registers : Registers
-}
-
-impl Machine {
-    pub fn new() -> Machine {
-        Machine { h : 0,
-                  s : 0,
-                  fail : false,
-                  heap : Vec::with_capacity(256),
-                  mode : MachineMode::Write,
-                  program : None,
-                  registers : vec![HeapCell::Ref(0); 33] }
-    }
-    
-    fn lookup(&self, a: Addr) -> &HeapCell {
-        match a {
-            Addr::HeapCell(hc) => &self.heap[hc],
-            Addr::RegNum(reg)  => &self.registers[reg]
-        }
-    }
-
-    fn deref(&self, a: Addr) -> Addr {
-        let mut a = a;
-
-        loop {
-            if let &HeapCell::Ref(value) = self.lookup(a) {
-                if let Addr::HeapCell(av) = a {
-                    if value != av {
-                        a = Addr::HeapCell(value);
-                        continue;
-                    }
-                }
-            }
-
-            return a;
-        };
-    }
-
-    fn is_unbound(hc: &HeapCell, index: usize) -> bool {
-        match hc {
-            &HeapCell::Ref(r) => r == index,
-            _ => false
-        }
-    }
-    
-    //TODO: try to compress this function. currently it is dog shit.
-    fn bind(&mut self, a: Addr, val: usize) {
-        let mut a = a;
-        
-        loop {
-            match a {
-                Addr::RegNum(reg) => {
-                    if let HeapCell::Ref(hc) = self.registers[reg] {
-                        a = Addr::HeapCell(hc);
-                    } else if Machine::is_unbound(&self.heap[val], val) {
-                        self.heap[val] = self.registers[reg].clone();
-                        break;
-                    } else {
-                        self.fail = true;
-                        break;
-                    }                        
-                },
-                Addr::HeapCell(hc) if Machine::is_unbound(&self.heap[hc], hc) => {
-                    self.heap[hc] = HeapCell::Ref(val);
-                    break;
-                },
-                Addr::HeapCell(hc) if Machine::is_unbound(&self.heap[val], val) => {                
-                    self.heap[val] = HeapCell::Ref(hc);
-                    break;
-                },
-                _ => {
-                    self.fail = true;                    
-                    break;
-                }
-            };
-        }
-    }
-
-    fn unify(&mut self, a1: Addr, a2: Addr) {
-        let mut pdl : Vec<Addr> = vec![a1, a2];
-
-        self.fail = false;
-
-        while !(pdl.is_empty() || self.fail) {
-            let d1 = self.deref(pdl.pop().unwrap());
-            let d2 = self.deref(pdl.pop().unwrap());
-
-            if d1 != d2 {
-                match (self.lookup(d1), self.lookup(d2)) {
-                    (&HeapCell::Ref(hc), _) =>
-                        self.bind(d2, hc),
-                    (_, &HeapCell::Ref(hc)) =>
-                        self.bind(d1, hc),
-                    (&HeapCell::Str(a1), &HeapCell::Str(a2)) => {
-                        let r1 = &self.heap[a1];
-                        let r2 = &self.heap[a2];
-
-                        if let &HeapCell::NamedStr(n1, ref f1) = r1 {
-                            if let &HeapCell::NamedStr(n2, ref f2) = r2 {
-                                if n1 == n2 && *f1 == *f2 {
-                                    for i in 1 .. n1 {
-                                        pdl.push(Addr::HeapCell(a1 + i));
-                                        pdl.push(Addr::HeapCell(a2 + i));
-                                    }
-
-                                    continue;
-                                }
-                            }
-                        }
-
-                        self.fail = true;
-                    },
-                    _ => self.fail = true,
-                };
-            }
-        }
-    }    
-
-    pub fn execute_query_instr<'a, 'b : 'a>(&'a mut self, instr: &'b QueryInstruction) {
-        match instr {
-            &QueryInstruction::PutStructure(ref name, arity, reg) => {
-                self.heap.push(HeapCell::Str(self.h + 1));
-                self.heap.push(HeapCell::NamedStr(arity, name.clone()));
-
-                self.registers[reg] = self.heap[self.h].clone();
-
-                self.h += 2;
-            },
-            &QueryInstruction::SetVariable(reg) => {
-                self.heap.push(HeapCell::Ref(self.h));
-                self.registers[reg] = self.heap[self.h].clone();
-
-                self.h += 1;
-            },
-            &QueryInstruction::SetValue(reg) => {
-                self.heap.push(self.registers[reg].clone());
-                self.h += 1;
-            },
-        }
-    }
-    
-    pub fn execute_fact_instr<'a, 'b : 'a>(&'a mut self, instr: &'b FactInstruction) {
-        match instr {
-            &FactInstruction::GetStructure(ref name, arity, reg) => {
-                let addr = self.deref(Addr::RegNum(reg));
-
-                match self.lookup(addr) {
-                    &HeapCell::Str(a) => {
-                        let result = &self.heap[a];
-
-                        if let &HeapCell::NamedStr(named_arity, ref named_str) = result {
-                            if arity == named_arity && *name == *named_str {
-                                self.s = a + 1;
-                                self.mode = MachineMode::Read;
-                            } else {
-                                self.fail = true;
-                            }
-                        }
-                    },
-                    &HeapCell::Ref(r) => {
-                        self.heap.push(HeapCell::Str(self.h + 1));
-                        self.heap.push(HeapCell::NamedStr(arity, name.clone()));
-
-                        let h = self.h;
-
-                        self.bind(Addr::HeapCell(r), h);
-
-                        self.h += 2;
-                        self.mode = MachineMode::Write;
-                    },
-                    _ => {
-                        self.fail = true;
-                    }
-                };
-            },
-            &FactInstruction::UnifyVariable(reg) => {
-                match self.mode {
-                    MachineMode::Read  => self.registers[reg] = self.heap[self.s].clone(),
-                    MachineMode::Write => {
-                        self.heap.push(HeapCell::Ref(self.h));
-                        self.registers[reg] = self.heap[self.h].clone();
-                        self.h += 1;
-                    }
-                };
-
-                self.s += 1;
-            },
-            &FactInstruction::UnifyValue(reg) => {
-                let s = self.s;
-
-                match self.mode {
-                    MachineMode::Read  => self.unify(Addr::RegNum(reg), Addr::HeapCell(s)),
-                    MachineMode::Write => {
-                        self.heap.push(self.registers[reg].clone());
-                        self.h += 1;
-                    }
-                };
-                
-                self.s += 1;
-            }
-        }
-    }
-    
-    pub fn reset_heap(&mut self) {
-        let program = self.program.take();
-
-        *self = Machine::new();
-        self.program = program;
-    }    
-}

src/l0/mod.rs

@@ -1,7 +0,0 @@
-mod l0_parser;
-
-pub mod ast;
-pub mod iterators;
-pub mod parser;
-pub mod codegen;
-pub mod machine;

src/l0/parser.rs

@@ -1,52 +0,0 @@
-use l0::ast::{Term, TopLevel, Var};
-use l0::l0_parser::{parse_TopLevel};
-
-use std::collections::{HashMap};
-
-extern crate lalrpop_util as __lalrpop_util;
-
-pub type ParseResult<'a> =
-    Result<TopLevel, __lalrpop_util::ParseError<usize,(usize, &'a str),()>>;
-
-pub fn parse_top_level<'a>(input: &'a str) -> ParseResult {
-    let result = parse_TopLevel(&*input);
-    
-    if let Ok(result) = result {
-        return Ok(mark_cells(result));
-    }
-
-    result
-}
-
-#[inline]
-fn mark_cells(tl: TopLevel) -> TopLevel {
-    match tl {
-        TopLevel::Fact(term) => TopLevel::Fact(mark_term_cells(term)),
-        TopLevel::Query(term) => TopLevel::Query(mark_term_cells(term))            
-    }
-}
-    
-fn mark_term_cells(term: Term) -> Term {
-    let mut cell_num = 1;    
-    
-    {
-        let mut bindings: HashMap<&Var, usize> = HashMap::new();
-        let mut iter = term.breadth_first_iter();
-    
-        while let Some(term) = iter.next() {
-            if let &Term::Var(ref cell, ref var) = term {
-                let cell_num_in_map = bindings.entry(var).or_insert(cell_num);
-                
-                if *cell_num_in_map != cell_num {                    
-                    cell.set(*cell_num_in_map);
-                    continue;
-                }
-            }
-
-            term.set_cell(cell_num);
-            cell_num += 1;
-        }
-    }
-
-    term
-}

src/l1/ast.rs

@@ -1,123 +0,0 @@
-use std::cell::Cell;
-use std::fmt;
-use std::vec::Vec;
-
-pub type Var = String;
-
-pub type Atom = String;
-
-pub enum TopLevel {
-    Fact(Term),
-    Query(Term)
-}
-
-#[derive(Clone, Copy)]
-pub enum Level {
-    Shallow, Deep
-}
-
-impl fmt::Display for Level {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &Level::Shallow => write!(f, "A"),
-            &Level::Deep => write!(f, "X")
-        }
-    }
-}
-
-#[derive(Clone, Copy)]
-pub enum Reg {
-    ArgAndNorm(usize, usize),
-    Norm(usize)
-}
-
-impl Reg {
-    pub fn has_arg(&self) -> bool {
-        match self {
-            &Reg::ArgAndNorm(_, _) => true,
-            _ => false
-        }
-    }
-
-    pub fn norm(&self) -> usize {
-        match self {
-            &Reg::ArgAndNorm(_, norm) | &Reg::Norm(norm) => norm
-        }
-    }
-}
-
-pub enum Term {
-    Atom(Cell<usize>, Atom),
-    Clause(Cell<usize>, Atom, Vec<Box<Term>>),
-    Var(Cell<Reg>, Var)
-}
-
-pub enum TermRef<'a> {
-    Atom(Level, &'a Cell<usize>, &'a Atom),
-    Clause(Level, &'a Cell<usize>, &'a Atom, &'a Vec<Box<Term>>),
-    Var(Level, &'a Cell<Reg>, &'a Var)
-}
-
-#[derive(Clone)]
-pub enum FactInstruction {
-    GetStructure(Level, Atom, usize, usize),
-    GetValue(usize, usize),
-    GetVariable(usize, usize),
-    Proceed,
-    UnifyVariable(usize),
-    UnifyValue(usize)
-}
-
-pub enum QueryInstruction {
-    Call(Atom, usize),
-    PutStructure(Level, Atom, usize, usize),
-    PutValue(usize, usize),
-    PutVariable(usize, usize),
-    SetVariable(usize),
-    SetValue(usize),
-}
-
-pub type CompiledFact = Vec<FactInstruction>;
-
-pub type CompiledQuery = Vec<QueryInstruction>;
-
-#[derive(Clone, Copy, PartialEq)]
-pub enum Addr {
-    HeapCell(usize),
-    RegNum(usize)
-}
-
-#[derive(Clone)]
-pub enum HeapCellValue {
-    NamedStr(usize, Atom),
-    Ref(usize),
-    Str(usize),
-}
-
-pub type Heap = Vec<HeapCellValue>;
-
-pub type Registers = Vec<HeapCellValue>;
-
-impl Term {
-    pub fn subterms(&self) -> usize {
-        match self {
-            &Term::Clause(_, _, ref terms) => terms.len(),
-            _ => 1
-        }
-    }
-
-    pub fn name(&self) -> &Atom {
-        match self {
-            &Term::Atom(_, ref atom)
-            | &Term::Var(_, ref atom)
-            | &Term::Clause(_, ref atom, _) => atom
-        }
-    }
-
-    pub fn arity(&self) -> usize {
-        match self {
-            &Term::Atom(_, _) | &Term::Var(_, _) => 0,
-            &Term::Clause(_, _, ref child_terms) => child_terms.len()
-        }
-    }
-}

src/l1/codegen.rs

@@ -1,312 +0,0 @@
-use l1::ast::{Atom, CompiledFact, CompiledQuery, FactInstruction,
-              Level, QueryInstruction, Reg, Term, TermRef, Var};
-use l1::iterators::{FactIterator, QueryIterator};
-
-use std::cell::Cell;
-use std::collections::HashMap;
-use std::fmt;
-use std::vec::Vec;
-
-impl fmt::Display for QueryInstruction {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &QueryInstruction::Call(ref name, ref arity) =>
-                write!(f, "call {}/{}", name, arity),
-            &QueryInstruction::PutStructure(ref lvl, ref a, ref s, ref r) =>
-                write!(f, "put_structure {}/{}, {}{}", a, s, lvl, r),
-            &QueryInstruction::PutValue(ref a, ref x) =>
-                write!(f, "put_value X{}, A{}", x, a),
-            &QueryInstruction::PutVariable(ref a, ref x) =>
-                write!(f, "put_variable X{}, A{}", x, a),
-            &QueryInstruction::SetVariable(ref r) =>
-                write!(f, "set_variable X{}", r),
-            &QueryInstruction::SetValue(ref r) =>
-                write!(f, "set_value X{}", r),
-        }
-    }
-}
-
-impl fmt::Display for FactInstruction {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &FactInstruction::GetStructure(ref lvl, ref a, ref s, ref r) =>
-                write!(f, "get_structure {}/{}, {}{}", a, s, lvl, r),
-            &FactInstruction::GetValue(ref a, ref x) =>
-                write!(f, "get_value X{}, A{}", x, a),
-            &FactInstruction::GetVariable(ref a, ref x) =>
-                write!(f, "get_variable X{}, A{}", x, a),
-            &FactInstruction::Proceed =>
-                write!(f, "proceed"),
-            &FactInstruction::UnifyVariable(ref r) =>
-                write!(f, "unify_variable X{}", r),
-            &FactInstruction::UnifyValue(ref r) =>
-                write!(f, "unify_value X{}", r)
-        }
-    }
-}
-
-struct TermMarker<'a> {    
-    bindings: HashMap<&'a Var, Reg>,
-    arg_c:    usize,
-    norm_c:   usize
-}
-
-impl<'a> TermMarker<'a> {
-    fn new(term: &'a Term) -> TermMarker<'a> {
-        TermMarker { bindings: HashMap::new(),
-                     arg_c:    1,
-                     norm_c:   term.subterms() + 1 }
-    }
-
-    fn contains_var(&self, var: &'a Var) -> bool {
-        self.bindings.contains_key(var)
-    }
-
-    fn get(&self, var: &'a Var) -> Reg {
-        *self.bindings.get(var).unwrap()
-    }
-
-    fn insert(&mut self, var: &'a Var, r: Reg) {
-        self.bindings.insert(var, r);
-    }
-    
-    fn mark_non_var(&mut self, lvl: Level, cell: &Cell<usize>) {
-        if cell.get() == 0 {            
-            match lvl {
-                Level::Deep => {
-                    let norm = self.norm_c;
-                    self.norm_c += 1;
-                    cell.set(norm);
-                },            
-                Level::Shallow => {
-                    let arg = self.arg_c;
-                    self.arg_c += 1;
-                    cell.set(arg);
-                }
-            };
-        }
-    }
-
-    fn mark_var(&mut self, lvl: Level, var: &'a Var) -> Reg {
-        if self.contains_var(var) {
-            let reg = self.get(var);
-
-            match lvl {
-                Level::Deep => Reg::Norm(reg.norm()),
-                Level::Shallow if reg.has_arg() => {
-                    let arg = self.arg_c;
-                    self.arg_c += 1;
-                    
-                    Reg::ArgAndNorm(arg, reg.norm())
-                },
-                Level::Shallow => {
-                    let norm = reg.norm();
-                    let reg  = Reg::ArgAndNorm(self.arg_c, norm);
-
-                    self.arg_c += 1;
-                    self.insert(var, reg);
-
-                    reg
-                }
-            }
-        } else {
-            let reg = match lvl {
-                Level::Deep    => Reg::Norm(self.norm_c),
-                Level::Shallow => {
-                    let reg = Reg::ArgAndNorm(self.arg_c, self.norm_c);
-                    self.arg_c += 1;
-                    reg
-                }
-            };
-
-            self.norm_c += 1;
-            self.insert(var, reg);
-            reg
-        }
-    }
-}
-
-trait CompilationTarget<'a> {
-    type Iterator : Iterator<Item=TermRef<'a>>;
-
-    fn iter(&'a Term) -> Self::Iterator;
-
-    fn to_structure(Level, Atom, usize, usize) -> Self;
-
-    fn argument_to_variable(usize, usize) -> Self;
-    fn argument_to_value(usize, usize) -> Self;
-    fn subterm_to_variable(usize) -> Self;
-    fn subterm_to_value(usize) -> Self;
-
-    fn clause_arg_to_instr(usize) -> Self;
-}
-
-impl<'a> CompilationTarget<'a> for FactInstruction {
-    type Iterator = FactIterator<'a>;
-
-    fn iter(term: &'a Term) -> Self::Iterator {
-        term.breadth_first_iter()
-    }
-
-    fn to_structure(lvl: Level, atom: Atom, arity: usize, cell_num: usize) -> Self {        
-        FactInstruction::GetStructure(lvl, atom, arity, cell_num)
-    }
-
-    fn argument_to_variable(arg: usize, val: usize) -> Self {
-        FactInstruction::GetVariable(arg, val)
-    }
-
-    fn argument_to_value(arg: usize, val: usize) -> Self {
-        FactInstruction::GetValue(arg, val)
-    }
-
-    fn subterm_to_variable(val: usize) -> Self {
-        FactInstruction::UnifyVariable(val)
-    }
-
-    fn subterm_to_value(val: usize) -> Self {
-        FactInstruction::UnifyValue(val)
-    }
-
-    fn clause_arg_to_instr(val: usize) -> Self {
-        FactInstruction::UnifyVariable(val)
-    }
-}
-
-impl<'a> CompilationTarget<'a> for QueryInstruction {
-    type Iterator = QueryIterator<'a>;
-
-    fn iter(term: &'a Term) -> Self::Iterator {
-        term.post_order_iter()
-    }
-
-    fn to_structure(lvl: Level, atom: Atom, arity: usize, cell_num: usize) -> Self {
-        QueryInstruction::PutStructure(lvl, atom, arity, cell_num)
-    }
-
-    fn argument_to_variable(arg: usize, val: usize) -> Self {
-        QueryInstruction::PutVariable(arg, val)
-    }
-
-    fn argument_to_value(arg: usize, val: usize) -> Self {
-        QueryInstruction::PutValue(arg, val)
-    }
-
-    fn subterm_to_variable(val: usize) -> Self {
-        QueryInstruction::SetVariable(val)
-    }
-
-    fn subterm_to_value(val: usize) -> Self {
-        QueryInstruction::SetValue(val)
-    }
-    
-    fn clause_arg_to_instr(val: usize) -> Self {
-        QueryInstruction::SetValue(val)
-    }
-}
-
-fn to_structure<'a, Target>(tm: &mut TermMarker<'a>,
-                            lvl: Level,
-                            name: &'a Atom,
-                            cell: &'a Cell<usize>,
-                            arity: usize)
-                            -> Target
-    where Target: CompilationTarget<'a>
-{
-    tm.mark_non_var(lvl, cell);
-    Target::to_structure(lvl, name.clone(), arity, cell.get())
-}
-
-fn non_var_subterm<'a, Target>(tm: &mut TermMarker<'a>, cell: &'a Cell<usize>)
-                               -> Target
-    where Target: CompilationTarget<'a>
-{
-    tm.mark_non_var(Level::Deep, cell);
-    Target::clause_arg_to_instr(cell.get())
-}
-
-fn var_term<'a, Target>(tm: &mut TermMarker<'a>,
-                        lvl: Level,
-                        cell: &'a Cell<Reg>,
-                        var: &'a Var)
-                        -> Target
-    where Target: CompilationTarget<'a>
-{
-    if !tm.contains_var(var) {
-        let reg = tm.mark_var(lvl, var);
-        cell.set(reg);
-        
-        match reg {
-            Reg::ArgAndNorm(arg, norm) =>
-                Target::argument_to_variable(arg, norm),
-            Reg::Norm(norm) =>
-                Target::subterm_to_variable(norm)
-        }
-    } else {
-        let reg = tm.mark_var(lvl, var);
-        cell.set(reg);
-        
-        match reg {
-            Reg::ArgAndNorm(arg, norm) =>
-                Target::argument_to_value(arg, norm),
-            Reg::Norm(norm) =>
-                Target::subterm_to_value(norm)
-        }
-    }
-}
-
-fn subterm_to_instr<'a, Target>(tm: &mut TermMarker<'a>, subterm: &'a Term)
-                                -> Target
-    where Target: CompilationTarget<'a>
-{
-    match subterm {
-        &Term::Atom(ref cell, _) | &Term::Clause(ref cell, _, _) =>
-            non_var_subterm(tm, cell),
-        &Term::Var(ref cell, ref var) =>
-            var_term(tm, Level::Deep, cell, var)
-    }
-}
-
-fn compile_target<'a, Target>(term: &'a Term) -> Vec<Target>
-    where Target: CompilationTarget<'a>
-{
-    let iter       = Target::iter(term);
-    let mut target = Vec::<Target>::new();
-    let mut marker = TermMarker::new(term);
-    
-    for term in iter {
-        match term {
-            TermRef::Atom(lvl, term, atom) =>
-                target.push(to_structure(&mut marker, lvl, atom, term, 0)),
-            TermRef::Clause(lvl, term, atom, terms) => {
-                target.push(to_structure(&mut marker, lvl, atom, term, terms.len()));
-
-                for subterm in terms {
-                    target.push(subterm_to_instr(&mut marker, subterm.as_ref()));
-                }
-            },
-            TermRef::Var(lvl @ Level::Shallow, ref cell, ref var) =>
-                target.push(var_term(&mut marker, lvl, cell, var)),
-            _ => {}
-        };
-    }
-
-    target
-}
-
-pub fn compile_fact(term: &Term) -> CompiledFact {
-    let mut compiled_fact = compile_target(term);
-
-    compiled_fact.push(FactInstruction::Proceed);
-    compiled_fact
-}
-
-pub fn compile_query<'a>(term: &'a Term) -> CompiledQuery {
-    let mut compiled_query = compile_target(term);
-
-    if let &Term::Clause(_, ref atom, ref terms) = term {
-        compiled_query.push(QueryInstruction::Call(atom.clone(), terms.len()));
-    }
-
-    compiled_query
-}

src/l1/iterators.rs

@@ -1,175 +0,0 @@
-use l1::ast::{Atom, Level, Reg, Term, TermRef, Var};
-
-use std::cell::Cell;
-use std::collections::VecDeque;
-use std::vec::Vec;
-
-enum IteratorState<'a> {
-    Atom(Level, &'a Cell<usize>, &'a Atom),
-    Clause(Level, usize, &'a Cell<usize>, &'a Atom, &'a Vec<Box<Term>>),
-    IsolatedAtom(&'a Cell<usize>, &'a Atom),
-    IsolatedVar(&'a Cell<Reg>, &'a Var),
-    RootClause(usize, &'a Vec<Box<Term>>),
-    Var(Level, &'a Cell<Reg>, &'a Var)
-}
-
-impl<'a> IteratorState<'a> {
-    fn to_state(lvl: Level, term: &'a Term) -> IteratorState<'a>
-    {
-        match term {
-            &Term::Atom(ref cell, ref atom) =>
-                IteratorState::Atom(lvl, cell, atom),
-            &Term::Clause(ref cell, ref atom, ref child_terms) =>
-                IteratorState::Clause(lvl, 0, cell, atom, child_terms),
-            &Term::Var(ref cell, ref var) =>
-                IteratorState::Var(lvl, cell, var)
-        }
-    }
-}
-
-pub struct QueryIterator<'a> {
-    state_stack: Vec<IteratorState<'a>>
-}
-
-impl<'a> QueryIterator<'a> {
-    fn push_clause(&mut self,
-                   lvl: Level,
-                   child_num: usize,
-                   cell: &'a Cell<usize>,
-                   name: &'a Atom,
-                   child_terms: &'a Vec<Box<Term>>)
-    {
-        self.state_stack.push(IteratorState::Clause(lvl,
-                                                    child_num,
-                                                    cell,
-                                                    name,
-                                                    child_terms));
-    }
-
-    fn push_root_clause(&mut self,
-                        child_num: usize,                        
-                        child_terms: &'a Vec<Box<Term>>)
-    {
-        self.state_stack.push(IteratorState::RootClause(child_num, child_terms));
-    }
-
-    fn push_subterm(&mut self, lvl: Level, term: &'a Term) {
-        self.state_stack.push(IteratorState::to_state(lvl, term));
-    }
-
-    fn new(term: &'a Term) -> QueryIterator<'a> {
-        let state = match term {
-            &Term::Atom(ref cell, ref atom) =>
-                IteratorState::IsolatedAtom(cell, atom),
-            &Term::Clause(_, _, ref terms) =>
-                IteratorState::RootClause(0, terms),
-            &Term::Var(ref cell, ref var) =>
-                IteratorState::IsolatedVar(cell, var)
-        };
-        
-        QueryIterator { state_stack: vec![state] }
-    }
-}
-
-impl<'a> Iterator for QueryIterator<'a> {
-    type Item = TermRef<'a>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        while let Some(iter_state) = self.state_stack.pop() {
-            match iter_state {
-                IteratorState::Atom(lvl, cell, atom) =>
-                    return Some(TermRef::Atom(lvl, cell, atom)),
-                IteratorState::Clause(lvl, child_num, cell, atom, child_terms) => {
-                    if child_num == child_terms.len() {
-                        return Some(TermRef::Clause(lvl, cell, atom, child_terms));
-                    } else {
-                        self.push_clause(lvl, child_num + 1, cell, atom, child_terms);
-                        self.push_subterm(Level::Deep, child_terms[child_num].as_ref());
-                    }
-                },
-                IteratorState::IsolatedAtom(cell, atom) =>
-                    return Some(TermRef::Atom(Level::Shallow, cell, atom)),
-                IteratorState::IsolatedVar(cell, var) =>
-                    return Some(TermRef::Var(Level::Shallow, cell, var)),
-                IteratorState::RootClause(child_num, child_terms) => {
-                    if child_num == child_terms.len() {
-                        return None;
-                    } else {
-                        self.push_root_clause(child_num + 1, child_terms);
-                        self.push_subterm(Level::Shallow, child_terms[child_num].as_ref());
-                    }
-                },
-                IteratorState::Var(lvl, cell, var) =>
-                    return Some(TermRef::Var(lvl, cell, var))
-            };
-        }
-
-        None
-    }
-}
-
-pub struct FactIterator<'a> {
-    state_queue: VecDeque<IteratorState<'a>>,
-}
-
-impl<'a> FactIterator<'a> {
-    fn push_subterm(&mut self, lvl: Level, term: &'a Term) {
-        self.state_queue.push_back(IteratorState::to_state(lvl, term));
-    }
-
-    fn new(term: &'a Term) -> FactIterator<'a> {
-        let states = match term {
-            &Term::Atom(ref cell, ref atom) =>
-                vec![IteratorState::IsolatedAtom(cell, atom)],
-            &Term::Clause(_, _, ref terms) =>
-                vec![IteratorState::RootClause(0, terms)],
-            &Term::Var(ref cell, ref var) =>
-                vec![IteratorState::IsolatedVar(cell, var)]
-        };
-
-        FactIterator { state_queue:  VecDeque::from(states) }
-    }
-}
-
-impl<'a> Iterator for FactIterator<'a> {
-    type Item = TermRef<'a>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        while let Some(state) = self.state_queue.pop_front() {
-            match state {
-                IteratorState::Atom(lvl, cell, atom) =>
-                    return Some(TermRef::Atom(lvl, cell, atom)),
-                IteratorState::Clause(lvl, _, cell, atom, child_terms) => {
-                    for child_term in child_terms {
-                        self.push_subterm(Level::Deep, child_term);
-                    }
-
-                    return Some(TermRef::Clause(lvl, cell, atom, child_terms));
-                },
-                IteratorState::IsolatedAtom(cell, atom) =>
-                    return Some(TermRef::Atom(Level::Shallow, cell, atom)),
-                IteratorState::IsolatedVar(cell, var) =>
-                    return Some(TermRef::Var(Level::Shallow, cell, var)),
-                IteratorState::RootClause(_, child_terms) => {
-                    for child_term in child_terms {
-                        self.push_subterm(Level::Shallow, child_term);
-                    }
-                },
-                IteratorState::Var(lvl, cell, var) =>
-                    return Some(TermRef::Var(lvl, cell, var))
-            }
-        }
-
-        None
-    }
-}
-
-impl Term {
-    pub fn post_order_iter(&self) -> QueryIterator {
-        QueryIterator::new(self)
-    }
-
-    pub fn breadth_first_iter(&self) -> FactIterator {
-        FactIterator::new(self)
-    }
-}

src/l1/l1_parser.lalrpop

@@ -1,32 +0,0 @@
-use std::cell::Cell;
-
-use l1::ast::{Atom, Reg, Term, TopLevel, Var};
-
-grammar;
-
-pub TopLevel: TopLevel = {
-    "?-" <t:Term> "." => TopLevel::Query(t),
-    <t:Term> "."      => TopLevel::Fact(t),
-};
-
-Atom : Atom = {
-    r"[a-z][a-z0-9_]*" => <>.trim().to_string(),
-};
-
-Var : Var = {
-    r"[A-Z][a-z0-9_]*" => <>.trim().to_string(),
-};
-
-BoxedTerm : Box<Term> = {
-    <t:Term> => Box::new(t),
-};
-
-Term : Term = {
-    <a:Atom> "(" <ts: (<BoxedTerm> ",")*> <t:BoxedTerm> ")" => {
-     	let mut ts = ts;
-     	ts.push(t);
-	Term::Clause(Cell::new(0), a, ts)
-    },
-    <Atom> => Term::Atom(Cell::new(0), <>),
-    <Var>  => Term::Var(Cell::new(Reg::Norm(0)), <>)
-};

src/l1/machine.rs

@@ -1,309 +0,0 @@
-use l1::ast::{Addr, Atom, CompiledFact, CompiledQuery,
-              FactInstruction, Heap, HeapCellValue, QueryInstruction,
-              Registers};
-
-use std::collections::HashMap;
-use std::vec::Vec;
-
-#[derive(Clone, Copy)]
-enum MachineMode {
-    Read,
-    Write
-}
-
-pub struct Machine {
-    h : usize,
-    s : usize,
-    p : usize,
-    code : CompiledFact,
-    code_dir : HashMap<(Atom, usize), usize>,
-    fail : bool,
-    heap : Heap,
-    mode : MachineMode,
-    registers : Registers
-}
-
-impl Machine {
-    pub fn new() -> Machine {
-        Machine { h : 0,
-                  s : 0,
-                  p : 0,
-                  code : Vec::new(),
-                  code_dir : HashMap::new(),
-                  fail : false,
-                  heap : Vec::with_capacity(256),
-                  mode : MachineMode::Write,
-                  registers : vec![HeapCellValue::Ref(0); 32] }
-    }
-
-    pub fn add_fact(&mut self, mut fact: CompiledFact, name: Atom, arity: usize)
-    {
-        let index = self.code.len();
-
-        self.code.append(&mut fact);
-        self.code_dir.insert((name, arity), index);
-    }
-
-    pub fn failed(&self) -> bool {
-        self.fail
-    }
-
-    fn lookup(&self, a: Addr) -> &HeapCellValue {
-        match a {
-            Addr::HeapCell(hc) => &self.heap[hc],
-            Addr::RegNum(reg)  => &self.registers[reg]
-        }
-    }
-
-    fn deref(&self, a: Addr) -> Addr {
-        let mut a = a;
-
-        loop {
-            if let &HeapCellValue::Ref(value) = self.lookup(a) {
-                if let Addr::HeapCell(av) = a {
-                    if value != av {
-                        a = Addr::HeapCell(value);
-                        continue;
-                    }
-                } else {
-                    a = Addr::HeapCell(value);
-                    continue;
-                }
-            }
-
-            return a;
-        };
-    }
-
-    fn is_unbound(hc: &HeapCellValue, index: usize) -> bool {
-        match hc {
-            &HeapCellValue::Ref(r) => r == index,
-            _ => false
-        }
-    }
-
-    //TODO: try to compress this function.
-    fn bind(&mut self, a: Addr, val: usize) {
-        let mut a = a;
-
-        loop {
-            match a {
-                Addr::RegNum(reg) => {
-                    if let HeapCellValue::Ref(hc) = self.registers[reg] {
-                        a = Addr::HeapCell(hc);
-                    } else if Machine::is_unbound(&self.heap[val], val) {
-                        self.heap[val] = self.registers[reg].clone();
-                        break;
-                    } else {
-                        self.fail = true;
-                        break;
-                    }
-                },
-                Addr::HeapCell(hc) if Machine::is_unbound(&self.heap[hc], hc) => {
-                    self.heap[hc] = HeapCellValue::Ref(val);
-                    break;
-                },
-                Addr::HeapCell(hc) if Machine::is_unbound(&self.heap[val], val) => {
-                    self.heap[val] = HeapCellValue::Ref(hc);
-                    break;
-                },
-                _ => {
-                    self.fail = true;
-                    break;
-                }
-            };
-        }
-    }
-
-    fn unify(&mut self, a1: Addr, a2: Addr) {
-        let mut pdl = vec![a1, a2];
-
-        self.fail = false;
-
-        while !(pdl.is_empty() || self.fail) {
-            let d1 = self.deref(pdl.pop().unwrap());
-            let d2 = self.deref(pdl.pop().unwrap());
-
-            if d1 != d2 {
-                match (self.lookup(d1), self.lookup(d2)) {
-                    (&HeapCellValue::Ref(hc), _) =>
-                        self.bind(d2, hc),
-                    (_, &HeapCellValue::Ref(hc)) =>
-                        self.bind(d1, hc),
-                    (&HeapCellValue::Str(a1), &HeapCellValue::Str(a2)) => {
-                        let r1 = &self.heap[a1];
-                        let r2 = &self.heap[a2];
-
-                        if let &HeapCellValue::NamedStr(n1, ref f1) = r1 {
-                            if let &HeapCellValue::NamedStr(n2, ref f2) = r2 {
-                                if n1 == n2 && *f1 == *f2 {
-                                    for i in 1 .. n1 {
-                                        pdl.push(Addr::HeapCell(a1 + i));
-                                        pdl.push(Addr::HeapCell(a2 + i));
-                                    }
-
-                                    continue;
-                                }
-                            }
-                        }
-
-                        self.fail = true;
-                    },
-                    _ => self.fail = true,
-                };
-            }
-        }
-    }
-
-    pub fn execute_fact(&mut self) {
-        loop {
-            if let &FactInstruction::Proceed = &self.code[self.p] {
-                break;
-            } else if self.fail {
-                break;
-            }
-
-            let fact_instr = self.code[self.p].clone();
-            self.execute_fact_instr(fact_instr);
-        }
-    }
-
-    pub fn execute_query(&mut self, query: &CompiledQuery) {
-        for instr in query {
-            self.execute_query_instr(instr);
-
-            if self.fail {
-                break;
-            }
-        }
-    }
-
-    fn execute_query_instr<'a, 'b: 'a>(&'a mut self, instr: &'b QueryInstruction) {
-        match instr {
-            &QueryInstruction::Call(ref name, arity) => {
-                // why is Option<&T> not Deref?!?!?
-                // is it because if the value is None, there's nothing to
-                // dereference?
-                let compiled_fact_index =
-                    self.code_dir.get(&(name.clone(), arity))
-                        .map(|index| *index);
-
-                match compiled_fact_index {
-                    Some(compiled_fact_index) => {
-                        self.p = compiled_fact_index;
-                        self.execute_fact();
-                    },
-                    None => self.fail = true,
-                };
-            }
-            &QueryInstruction::PutStructure(_, ref name, arity, reg) => {
-                self.heap.push(HeapCellValue::Str(self.h + 1));
-                self.heap.push(HeapCellValue::NamedStr(arity, name.clone()));
-
-                self.registers[reg] = self.heap[self.h].clone();
-
-                self.h += 2;
-            },
-            &QueryInstruction::PutValue(arg, norm) =>
-                self.registers[arg] = self.registers[norm].clone(),
-            &QueryInstruction::PutVariable(arg, norm) => {
-                self.heap.push(HeapCellValue::Ref(self.h));
-
-                self.registers[norm] = self.heap[self.h].clone();
-                self.registers[arg]  = self.heap[self.h].clone();
-
-                self.h += 1;
-            },
-            &QueryInstruction::SetVariable(reg) => {
-                self.heap.push(HeapCellValue::Ref(self.h));
-                self.registers[reg] = self.heap[self.h].clone();
-
-                self.h += 1;
-            },
-            &QueryInstruction::SetValue(reg) => {
-                self.heap.push(self.registers[reg].clone());
-                self.h += 1;
-            },
-        }
-    }
-
-    fn execute_fact_instr(&mut self, instr: FactInstruction) {
-        match instr {
-            FactInstruction::Proceed => return,
-            FactInstruction::GetStructure(_, name, arity, reg) => {
-                let addr = self.deref(Addr::RegNum(reg));
-
-                match self.lookup(addr) {
-                    &HeapCellValue::Str(a) => {
-                        let result = &self.heap[a];
-
-                        if let &HeapCellValue::NamedStr(named_arity, ref named_str) = result {
-                            if arity == named_arity && *name == *named_str {
-                                self.s = a + 1;
-                                self.mode = MachineMode::Read;
-                            } else {
-                                self.fail = true;
-                            }
-                        }
-                    },
-                    &HeapCellValue::Ref(r) => {
-                        self.heap.push(HeapCellValue::Str(self.h + 1));
-                        self.heap.push(HeapCellValue::NamedStr(arity, name));
-
-                        let h = self.h;
-
-                        self.bind(Addr::HeapCell(r), h);
-
-                        self.h += 2;
-                        self.mode = MachineMode::Write;
-                    },
-                    _ => {
-                        self.fail = true;
-                    }
-                };
-            },
-            FactInstruction::GetVariable(arg, norm) =>
-                self.registers[norm] = self.registers[arg].clone(),
-            FactInstruction::GetValue(arg, norm) =>
-                self.unify(Addr::RegNum(norm), Addr::RegNum(arg)),
-            FactInstruction::UnifyVariable(reg) => {
-                match self.mode {
-                    MachineMode::Read  => self.registers[reg] = self.heap[self.s].clone(),
-                    MachineMode::Write => {
-                        self.heap.push(HeapCellValue::Ref(self.h));
-                        self.registers[reg] = self.heap[self.h].clone();
-                        self.h += 1;
-                    }
-                };
-
-                self.s += 1;
-            },
-            FactInstruction::UnifyValue(reg) => {
-                let s = self.s;
-
-                match self.mode {
-                    MachineMode::Read  => self.unify(Addr::RegNum(reg), Addr::HeapCell(s)),
-                    MachineMode::Write => {
-                        self.heap.push(self.registers[reg].clone());
-                        self.h += 1;
-                    }
-                };
-
-                self.s += 1;
-            }
-        }
-
-        self.p += 1;
-    }
-
-    pub fn reset_machine_state(&mut self) {
-        self.h = 0;
-        self.s = 0;
-        self.p = 0;
-
-        self.fail = false;
-        self.heap = Vec::with_capacity(256);
-        self.mode = MachineMode::Write;
-        self.registers = vec![HeapCellValue::Ref(0); 32];
-    }
-}

src/l1/mod.rs

@@ -1,5 +0,0 @@
-pub mod ast;
-pub mod iterators;
-pub mod l1_parser;
-pub mod codegen;
-pub mod machine;

src/l2/ast.rs

@@ -1,253 +0,0 @@
-use std::cell::Cell;
-use std::fmt;
-use std::ops::{Add, AddAssign};
-use std::vec::Vec;
-
-pub type Var = String;
-
-pub type Atom = String;
-
-pub enum TopLevel {
-    Fact(Term),
-    Rule(Rule),
-    Query(Term)
-}
-
-#[derive(Clone, Copy)]
-pub enum Level {
-    Shallow, Deep
-}
-
-impl fmt::Display for Level {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &Level::Shallow => write!(f, "A"),
-            &Level::Deep => write!(f, "X")
-        }
-    }
-}
-
-#[derive(Clone, Copy)]
-pub enum RegType {
-    Perm(usize),
-    Temp(usize)
-}
-
-impl RegType {
-    pub fn reg_num(self) -> usize {
-        match self {
-            RegType::Perm(reg_num) | RegType::Temp(reg_num) => reg_num
-        }
-    }
-
-    pub fn is_perm(self) -> bool {
-        match self {
-            RegType::Perm(_) => true,
-            _ => false
-        }
-    }
-}
-
-impl fmt::Display for VarReg {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &VarReg::Norm(RegType::Perm(reg)) => write!(f, "Y{}", reg),
-            &VarReg::Norm(RegType::Temp(reg)) => write!(f, "X{}", reg),
-            &VarReg::ArgAndNorm(RegType::Perm(reg), arg) =>
-                write!(f, "Y{} A{}", reg, arg),
-            &VarReg::ArgAndNorm(RegType::Temp(reg), arg) =>
-                write!(f, "X{} A{}", reg, arg)
-        }
-    }
-}
-
-impl From<RegType> for Addr {
-    fn from(reg: RegType) -> Addr {
-        match reg {
-            RegType::Perm(reg) => Addr::StackCell(reg),
-            RegType::Temp(reg) => Addr::RegNum(reg)
-        }
-    }
-}
-
-impl fmt::Display for RegType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &RegType::Perm(val) => write!(f, "Y{}", val),
-            &RegType::Temp(val) => write!(f, "X{}", val)
-        }
-    }
-}
-
-#[derive(Clone, Copy)]
-pub enum VarReg {
-    ArgAndNorm(RegType, usize),
-    Norm(RegType)
-}
-
-impl VarReg {
-    pub fn norm(self) -> RegType {
-        match self {
-            VarReg::ArgAndNorm(reg, _) | VarReg::Norm(reg) => reg
-        }
-    }
-
-    pub fn root_register(self) -> usize {
-        match self {
-            VarReg::ArgAndNorm(_, root) => root,
-            VarReg::Norm(root) => root.reg_num()
-        }
-    }
-}
-
-pub enum Term {
-    Atom(Cell<RegType>, Atom),
-    Clause(Cell<RegType>, Atom, Vec<Box<Term>>),
-    Var(Cell<VarReg>, Var)
-}
-
-pub struct Rule {
-    pub head: (Term, Term),
-    pub clauses: Vec<Term>
-}
-
-pub enum TermRef<'a> {
-    Atom(Level, &'a Cell<RegType>, &'a Atom),
-    Clause(Level, &'a Cell<RegType>, &'a Atom, &'a Vec<Box<Term>>),
-    Var(Level, &'a Cell<VarReg>, &'a Var)
-}
-
-pub enum FactInstruction {
-    GetStructure(Level, Atom, usize, RegType),
-    GetValue(RegType, usize),
-    GetVariable(RegType, usize),
-    UnifyVariable(RegType),
-    UnifyValue(RegType)
-}
-
-pub enum QueryInstruction {
-    PutStructure(Level, Atom, usize, RegType),
-    PutValue(RegType, usize),
-    PutVariable(RegType, usize),
-    SetVariable(RegType),
-    SetValue(RegType)
-}
-
-pub enum ControlInstruction {
-    Allocate(usize),
-    Call(Atom, usize),
-    Deallocate,
-    Proceed
-}
-
-pub type CompiledFact = Vec<FactInstruction>;
-
-pub type CompiledQuery = Vec<QueryInstruction>;
-
-pub enum Line {
-    Control(ControlInstruction),    
-    Fact(CompiledFact),
-    Query(CompiledQuery)
-}
-
-pub type Code = Vec<Line>;
-
-#[derive(Clone, Copy, PartialEq)]
-pub enum Addr {
-    HeapCell(usize),
-    RegNum(usize),
-    StackCell(usize),
-}
-
-#[derive(Clone, PartialEq)]
-pub enum HeapCellValue {
-    NamedStr(usize, Atom),
-    Ref(usize),
-    Str(usize)
-}
-
-impl HeapCellValue {
-    pub fn as_ref(&self, focus: usize) -> HeapCellRef {
-        match self {
-            &HeapCellValue::Ref(r) => HeapCellRef::Ref(r),
-            &HeapCellValue::Str(s) => HeapCellRef::Str(s),
-            &HeapCellValue::NamedStr(_, _) => HeapCellRef::Str(focus)
-        }
-    }
-}
-
-#[derive(Copy, Clone)]
-pub enum HeapCellRef {
-    Ref(usize),
-    Str(usize)
-}
-
-impl HeapCellRef {
-    pub fn heap_offset(&self) -> usize {
-        match self {
-            &HeapCellRef::Ref(r) | &HeapCellRef::Str(r) => r
-        }
-    }        
-}
-
-impl From<HeapCellRef> for HeapCellValue {
-    fn from(hcr: HeapCellRef) -> HeapCellValue {
-        match hcr {
-            HeapCellRef::Ref(r) => HeapCellValue::Ref(r),
-            HeapCellRef::Str(s) => HeapCellValue::Str(s)
-        }
-    }
-}
-
-#[derive(Clone, Copy)]
-pub enum CodePtr {
-    DirEntry(usize),
-    TopLevel
-}
-
-impl Add<usize> for CodePtr {
-    type Output = CodePtr;
-    fn add(self, rhs: usize) -> Self::Output {
-        match self {
-            CodePtr::DirEntry(p) => CodePtr::DirEntry(p + rhs),
-            CodePtr::TopLevel => CodePtr::TopLevel
-        }
-    }
-}
-
-impl AddAssign<usize> for CodePtr {
-    fn add_assign(&mut self, rhs: usize) {
-        match self {
-            &mut CodePtr::DirEntry(ref mut p) => *p += rhs,
-            _ => {}
-        }
-    }
-}
-
-pub type Heap = Vec<HeapCellValue>;
-
-pub type Registers = Vec<HeapCellRef>;
-
-impl Term {
-    pub fn subterms(&self) -> usize {
-        match self {
-            &Term::Clause(_, _, ref terms) => terms.len(),
-            _ => 1
-        }
-    }
-
-    pub fn name(&self) -> &Atom {
-        match self {
-            &Term::Atom(_, ref atom)
-            | &Term::Var(_, ref atom)
-            | &Term::Clause(_, ref atom, _) => atom
-        }
-    }
-
-    pub fn arity(&self) -> usize {
-        match self {
-            &Term::Atom(_, _) | &Term::Var(_, _) => 0,
-            &Term::Clause(_, _, ref child_terms) => child_terms.len()
-        }
-    }
-}

src/l2/codegen.rs

@@ -1,469 +0,0 @@
-use l2::ast::*;
-use l2::iterators::{FactIterator, QueryIterator};
-
-use std::cell::Cell;
-use std::cmp::max;
-use std::collections::HashMap;
-use std::fmt;
-use std::vec::Vec;
-
-impl fmt::Display for FactInstruction {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &FactInstruction::GetStructure(Level::Deep, ref name, ref arity, ref r) =>
-                write!(f, "get_structure {}/{}, {}", name, arity, r),
-            &FactInstruction::GetStructure(Level::Shallow, ref name, ref arity, ref r) =>
-                write!(f, "get_structure {}/{}, A{}", name, arity, r.reg_num()),
-            &FactInstruction::GetValue(ref x, ref a) =>
-                write!(f, "get_value {}, A{}", x, a),
-            &FactInstruction::GetVariable(ref x, ref a) =>
-                write!(f, "get_variable {}, A{}", x, a),
-            &FactInstruction::UnifyVariable(ref r) =>
-                write!(f, "unify_variable {}", r),
-            &FactInstruction::UnifyValue(ref r) =>
-                write!(f, "unify_value {}", r)
-        }
-    }
-}
-
-impl fmt::Display for QueryInstruction {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &QueryInstruction::PutStructure(Level::Deep, ref name, ref arity, ref r) =>
-                write!(f, "put_structure {}/{}, A{}", name, arity, r.reg_num()),
-            &QueryInstruction::PutStructure(Level::Shallow, ref name, ref arity, ref r) =>
-                write!(f, "put_structure {}/{}, {}", name, arity, r),
-            &QueryInstruction::PutValue(ref x, ref a) =>
-                write!(f, "put_value {}, A{}", x, a),
-            &QueryInstruction::PutVariable(ref x, ref a) =>
-                write!(f, "put_variable {}, A{}", x, a),
-            &QueryInstruction::SetVariable(ref r) =>
-                write!(f, "set_variable {}", r),
-            &QueryInstruction::SetValue(ref r) =>
-                write!(f, "set_value {}", r),
-        }
-    }
-}
-
-impl fmt::Display for ControlInstruction {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &ControlInstruction::Allocate(num_cells) =>
-                write!(f, "allocate {}", num_cells),
-            &ControlInstruction::Call(ref name, ref arity) =>
-                write!(f, "call {}/{}", name, arity),
-            &ControlInstruction::Deallocate =>
-                write!(f, "deallocate"),
-            &ControlInstruction::Proceed =>
-                write!(f, "proceed")
-        }
-    }
-}
-
-trait CompilationTarget<'a> {
-    type Iterator : Iterator<Item=TermRef<'a>>;
-
-    fn iter(&'a Term) -> Self::Iterator;
-
-    fn to_structure(Level, Atom, usize, RegType) -> Self;
-
-    fn argument_to_variable(RegType, usize) -> Self;
-    fn argument_to_value(RegType, usize) -> Self;
-    fn subterm_to_variable(RegType) -> Self;
-    fn subterm_to_value(RegType) -> Self;
-
-    fn clause_arg_to_instr(RegType) -> Self;
-}
-
-impl<'a> CompilationTarget<'a> for FactInstruction {
-    type Iterator = FactIterator<'a>;
-
-    fn iter(term: &'a Term) -> Self::Iterator {
-        term.breadth_first_iter()
-    }
-
-    fn to_structure(lvl: Level, atom: Atom, arity: usize, reg: RegType) -> Self {
-        FactInstruction::GetStructure(lvl, atom, arity, reg)
-    }
-
-    fn argument_to_variable(arg: RegType, val: usize) -> Self {
-        FactInstruction::GetVariable(arg, val)
-    }
-
-    fn argument_to_value(arg: RegType, val: usize) -> Self {
-        FactInstruction::GetValue(arg, val)
-    }
-
-    fn subterm_to_variable(val: RegType) -> Self {
-        FactInstruction::UnifyVariable(val)
-    }
-
-    fn subterm_to_value(val: RegType) -> Self {
-        FactInstruction::UnifyValue(val)
-    }
-
-    fn clause_arg_to_instr(val: RegType) -> Self {
-        FactInstruction::UnifyVariable(val)
-    }
-}
-
-impl<'a> CompilationTarget<'a> for QueryInstruction {
-    type Iterator = QueryIterator<'a>;
-
-    fn iter(term: &'a Term) -> Self::Iterator {
-        term.post_order_iter()
-    }
-
-    fn to_structure(lvl: Level, atom: Atom, arity: usize, reg: RegType) -> Self {
-        QueryInstruction::PutStructure(lvl, atom, arity, reg)
-    }
-
-    fn argument_to_variable(arg: RegType, val: usize) -> Self {
-        QueryInstruction::PutVariable(arg, val)
-    }
-
-    fn argument_to_value(arg: RegType, val: usize) -> Self {
-        QueryInstruction::PutValue(arg, val)
-    }
-
-    fn subterm_to_variable(val: RegType) -> Self {
-        QueryInstruction::SetVariable(val)
-    }
-
-    fn subterm_to_value(val: RegType) -> Self {
-        QueryInstruction::SetValue(val)
-    }
-
-    fn clause_arg_to_instr(val: RegType) -> Self {
-        QueryInstruction::SetValue(val)
-    }
-}
-
-struct TermMarker<'a> {
-    bindings: HashMap<&'a Var, VarReg>,
-    arg_c:    usize,
-    perm_c:   usize,
-    temp_c:   usize
-}
-
-impl<'a> TermMarker<'a> {
-    fn new() -> TermMarker<'a> {
-        TermMarker { bindings: HashMap::new(),
-                     arg_c:    1,
-                     perm_c:   1,
-                     temp_c:   1 }
-    }
-
-    fn contains_var(&self, var: &'a Var) -> bool {
-        self.bindings.contains_key(var)
-    }
-
-    fn get(&self, var: &'a Var) -> VarReg {
-        *self.bindings.get(var).unwrap()
-    }
-
-    fn insert(&mut self, var: &'a Var, r: VarReg) {
-        self.bindings.insert(var, r);
-    }
-
-    fn mark_non_var(&mut self, lvl: Level, cell: &Cell<RegType>) {
-        let reg_type = cell.get();
-
-        if reg_type.reg_num() == 0 {
-            match lvl {
-                Level::Deep if reg_type.is_perm() => {
-                    let perm = self.perm_c;
-                    self.perm_c += 1;
-                    cell.set(RegType::Perm(perm));
-                },
-                Level::Deep => {
-                    let temp = self.temp_c;
-                    self.temp_c += 1;
-                    cell.set(RegType::Temp(temp));
-                },
-                Level::Shallow if reg_type.is_perm() => {
-                    let arg = self.arg_c;
-                    self.arg_c += 1;
-                    cell.set(RegType::Perm(arg));
-                },
-                Level::Shallow => {
-                    let arg = self.arg_c;
-                    self.arg_c += 1;
-                    cell.set(RegType::Temp(arg));
-                }
-            };
-        }
-    }
-
-    fn mark_old_var(&mut self, lvl: Level, var: &'a Var) -> VarReg
-    {
-        let reg = self.get(var);
-
-        match lvl {
-            Level::Deep => VarReg::Norm(reg.norm()),
-            Level::Shallow => {
-                let reg = VarReg::ArgAndNorm(reg.norm(), self.arg_c);
-
-                self.arg_c += 1;
-                self.insert(var, reg);
-
-                reg
-            }
-        }
-    }
-
-    fn mark_new_var(&mut self, lvl: Level, var: &'a Var, reg: RegType) -> VarReg
-    {
-        let inner_reg = if reg.is_perm() {
-            let perm = self.perm_c;
-            self.perm_c += 1;
-            RegType::Perm(perm)
-        } else {
-            let temp = self.temp_c;
-            self.temp_c += 1;
-            RegType::Temp(temp)
-        };
-
-        let reg = match lvl {
-            Level::Deep => VarReg::Norm(inner_reg),
-            Level::Shallow => {
-                let reg = VarReg::ArgAndNorm(inner_reg, self.arg_c);
-                self.arg_c += 1;
-                reg
-            }
-        };
-
-        self.insert(var, reg);
-        reg
-    }
-
-    fn advance_at_header(&mut self, term: &'a Term) {
-        self.arg_c = 1;
-        self.temp_c = max(term.subterms(), self.temp_c) + 1;
-    }
-
-    fn advance(&mut self, term: &'a Term) {
-        self.arg_c = 1;
-        self.temp_c = term.subterms() + 1;
-    }
-}
-
-#[derive(Copy, Clone)]
-enum TermStatus {
-    New, Old, Recurrent
-}
-
-pub struct CodeGenerator<'a> {
-    marker: TermMarker<'a>
-}
-
-type VariableFixture<'a>  = (TermStatus, Vec<&'a Cell<VarReg>>);
-type VariableFixtures<'a> = HashMap<&'a Var, VariableFixture<'a>>;
-
-impl<'a> CodeGenerator<'a> {
-    pub fn new() -> Self {
-        CodeGenerator { marker: TermMarker::new() }
-    }
-
-    pub fn vars(&self) -> &HashMap<&Var, VarReg> {
-        &self.marker.bindings
-    }
-
-    fn to_structure<Target>(&mut self,
-                            lvl: Level,
-                            name: &'a Atom,
-                            cell: &'a Cell<RegType>,
-                            arity: usize)
-                            -> Target
-        where Target: CompilationTarget<'a>
-    {
-        self.marker.mark_non_var(lvl, cell);
-        Target::to_structure(lvl, name.clone(), arity, cell.get())
-    }
-
-    fn var_term<Target>(&mut self,
-                        lvl: Level,
-                        cell: &'a Cell<VarReg>,
-                        var: &'a Var)
-                        -> Target
-        where Target: CompilationTarget<'a>
-    {
-        if !self.marker.contains_var(var) {
-            let reg = self.marker.mark_new_var(lvl, var, cell.get().norm());
-            cell.set(reg);
-
-            match reg {
-                VarReg::ArgAndNorm(arg, norm) =>
-                    Target::argument_to_variable(arg, norm),
-                VarReg::Norm(norm) =>
-                    Target::subterm_to_variable(norm)
-            }
-        } else {
-            let reg = self.marker.mark_old_var(lvl, var);
-            cell.set(reg);
-
-            match reg {
-                VarReg::ArgAndNorm(arg, norm) =>
-                    Target::argument_to_value(arg, norm),
-                VarReg::Norm(norm) =>
-                    Target::subterm_to_value(norm)
-            }
-        }
-    }
-
-    fn non_var_subterm<Target>(&mut self, cell: &'a Cell<RegType>) -> Target
-        where Target: CompilationTarget<'a>
-    {
-        self.marker.mark_non_var(Level::Deep, cell);
-        Target::clause_arg_to_instr(cell.get())
-    }
-
-    fn subterm_to_instr<Target>(&mut self, subterm: &'a Term) -> Target
-        where Target: CompilationTarget<'a>
-    {
-        match subterm {
-            &Term::Atom(ref cell, _) | &Term::Clause(ref cell, _, _) =>
-                self.non_var_subterm(cell),
-            &Term::Var(ref cell, ref var) =>
-                self.var_term(Level::Deep, cell, var)
-        }
-    }
-
-    fn compile_target<Target>(&mut self, term: &'a Term) -> Vec<Target>
-        where Target: CompilationTarget<'a>
-    {
-        let iter       = Target::iter(term);
-        let mut target = Vec::new();
-
-        for term in iter {
-            match term {
-                TermRef::Atom(lvl, term, atom) =>
-                    target.push(self.to_structure(lvl, atom, term, 0)),
-                TermRef::Clause(lvl, term, atom, terms) => {
-                    target.push(self.to_structure(lvl, atom, term, terms.len()));
-
-                    for subterm in terms {
-                        target.push(self.subterm_to_instr(subterm.as_ref()));
-                    }
-                },
-                TermRef::Var(lvl @ Level::Shallow, ref cell, ref var) =>
-                    target.push(self.var_term(lvl, cell, var)),
-                _ => {}
-            };
-        }
-
-        target
-    }
-
-    fn mark_vars_in_term<Iter>(iter: Iter, vs: &mut VariableFixtures<'a>)
-        where Iter : Iterator<Item=TermRef<'a>>
-    {
-        for term in iter {
-            if let TermRef::Var(_, reg_cell, var) = term {
-                let mut status = vs.entry(var)
-                                   .or_insert((TermStatus::New, Vec::new()));
-
-                status.1.push(reg_cell);
-
-                match status.0 {
-                    TermStatus::Old => status.0 = TermStatus::Recurrent,
-                    _ => {}
-                };
-            }
-        }
-
-        for &mut (ref mut term_status, ref mut cb) in vs.values_mut() {
-            match *term_status {
-                TermStatus::New => *term_status = TermStatus::Old,
-                TermStatus::Recurrent => {
-                    for cell_reg in cb.drain(0..) {
-                        cell_reg.set(VarReg::Norm(RegType::Perm(0)));
-                    }
-                },
-                _ => {}
-            }
-        }
-    }
-
-    fn mark_perm_vars(rule: &'a Rule) -> VariableFixtures {
-        let &Rule { head: (ref p0, ref p1), ref clauses } = rule;
-        let mut vfs = HashMap::new();
-
-        let iter = p0.breadth_first_iter().chain(p1.breadth_first_iter());
-
-        Self::mark_vars_in_term(iter, &mut vfs);
-
-        for term in clauses {
-            Self::mark_vars_in_term(term.breadth_first_iter(), &mut vfs);
-        }
-
-        vfs
-    }
-
-    fn add_conditional_call(compiled_query: &mut Code, term: &Term) {
-        match term {
-            &Term::Atom(_, ref atom) => {
-                let call = ControlInstruction::Call(atom.clone(), 0);
-                compiled_query.push(Line::Control(call));
-            },
-            &Term::Clause(_, ref atom, ref terms) => {
-                let call = ControlInstruction::Call(atom.clone(), terms.len());
-                compiled_query.push(Line::Control(call));
-            },
-            _ => {}
-        }
-    }
-
-    pub fn compile_rule(&mut self, rule: &'a Rule) -> Code {
-        let vfs = Self::mark_perm_vars(&rule);
-        let &Rule { head: (ref p0, ref p1), ref clauses } = rule;
-        let mut perm_vars = 0;
-
-        for &(term_status, _) in vfs.values() {
-            if let TermStatus::Recurrent = term_status {
-                perm_vars += 1;
-            }
-        }
-
-        let mut body = Vec::new();
-
-        body.push(Line::Control(ControlInstruction::Allocate(perm_vars)));
-
-        self.marker.advance(p0);
-        body.push(Line::Fact(self.compile_target(p0)));
-
-        self.marker.advance_at_header(p1);
-        body.push(Line::Query(self.compile_target(p1)));
-        Self::add_conditional_call(&mut body, p1);
-
-        body = clauses.iter()
-            .map(|ref term| self.compile_query(term))
-            .fold(body, |mut body, ref mut cqs| {
-                body.append(cqs);
-                body
-            });
-
-        body.push(Line::Control(ControlInstruction::Deallocate));
-
-        body
-    }
-
-    pub fn compile_fact(&mut self, term: &'a Term) -> Code {
-        self.marker.advance(term);
-
-        let mut compiled_fact = vec![Line::Fact(self.compile_target(term))];
-        let proceed = Line::Control(ControlInstruction::Proceed);
-
-        compiled_fact.push(proceed);
-        compiled_fact
-    }
-
-    pub fn compile_query(&mut self, term: &'a Term) -> Code {
-        self.marker.advance(term);
-
-        let mut compiled_query = vec![Line::Query(self.compile_target(term))];
-        Self::add_conditional_call(&mut compiled_query, term);
-
-        compiled_query
-    }
-}

src/l2/heapview.rs

@@ -1,64 +0,0 @@
-use l2::ast::*;
-
-use std::vec::Vec;
-
-#[derive(Clone, Copy)]
-pub enum HeapCellView<'a> {
-    Str(usize, &'a Atom),
-    Var(usize)
-}
-
-pub struct HeapCellViewer<'a> {
-    heap: &'a Heap,
-    state_stack: Vec<(usize, &'a HeapCellValue)>
-}
-
-impl<'a> HeapCellViewer<'a> {
-    pub fn new(heap: &'a Heap, focus: usize) -> Self {
-        HeapCellViewer {
-            heap: heap,
-            state_stack: vec![(focus, &heap[focus])]
-        }
-    }
-
-    fn follow(&self, value: &'a HeapCellValue) -> &'a HeapCellValue {
-        match value {
-            &HeapCellValue::NamedStr(_, _) => value,
-            &HeapCellValue::Ref(cell_num) | &HeapCellValue::Str(cell_num) =>
-                &self.heap[cell_num],
-        }
-    }
-}
-
-impl<'a> Iterator for HeapCellViewer<'a> {
-    type Item = HeapCellView<'a>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        while let Some(hcv) = self.state_stack.pop() {
-            match hcv {
-                (focus, &HeapCellValue::NamedStr(arity, ref name)) => {
-                    for i in (1 .. arity + 1).rev() {
-                        self.state_stack.push((focus + i, &self.heap[focus + i]));
-                    }                            
-                    
-                    return Some(HeapCellView::Str(arity, name));
-                },
-                (_, &HeapCellValue::Ref(cell_num)) => {
-                    let new_hcv = self.follow(hcv.1);
-
-                    if hcv.1 == new_hcv {
-                        return Some(HeapCellView::Var(cell_num));
-                    } else {
-                        self.state_stack.push((cell_num, new_hcv));
-                    }
-                },
-                (_, &HeapCellValue::Str(cell_num)) => {
-                    let new_hcv = self.follow(hcv.1);
-                    self.state_stack.push((cell_num, new_hcv));
-                }
-            }
-        }
-
-        None
-    }
-}

src/l2/iterators.rs

@@ -1,175 +0,0 @@
-use l2::ast::*;
-
-use std::cell::Cell;
-use std::collections::VecDeque;
-use std::vec::Vec;
-
-enum IteratorState<'a> {
-    Atom(Level, &'a Cell<RegType>, &'a Atom),
-    Clause(Level, usize, &'a Cell<RegType>, &'a Atom, &'a Vec<Box<Term>>),
-    IsolatedAtom(&'a Cell<RegType>, &'a Atom),
-    IsolatedVar(&'a Cell<VarReg>, &'a Var),
-    RootClause(usize, &'a Vec<Box<Term>>),
-    Var(Level, &'a Cell<VarReg>, &'a Var)
-}
-
-impl<'a> IteratorState<'a> {
-    fn to_state(lvl: Level, term: &'a Term) -> IteratorState<'a>
-    {
-        match term {
-            &Term::Atom(ref cell, ref atom) =>
-                IteratorState::Atom(lvl, cell, atom),
-            &Term::Clause(ref cell, ref atom, ref child_terms) =>
-                IteratorState::Clause(lvl, 0, cell, atom, child_terms),
-            &Term::Var(ref cell, ref var) =>
-                IteratorState::Var(lvl, cell, var)
-        }
-    }
-}
-
-pub struct QueryIterator<'a> {
-    state_stack: Vec<IteratorState<'a>>
-}
-
-impl<'a> QueryIterator<'a> {
-    fn push_clause(&mut self,
-                   lvl: Level,
-                   child_num: usize,
-                   cell: &'a Cell<RegType>,
-                   name: &'a Atom,
-                   child_terms: &'a Vec<Box<Term>>)
-    {
-        self.state_stack.push(IteratorState::Clause(lvl,
-                                                    child_num,
-                                                    cell,
-                                                    name,
-                                                    child_terms));
-    }
-
-    fn push_root_clause(&mut self,
-                        child_num: usize,
-                        child_terms: &'a Vec<Box<Term>>)
-    {
-        self.state_stack.push(IteratorState::RootClause(child_num, child_terms));
-    }
-
-    fn push_subterm(&mut self, lvl: Level, term: &'a Term) {
-        self.state_stack.push(IteratorState::to_state(lvl, term));
-    }
-
-    fn new(term: &'a Term) -> QueryIterator<'a> {
-        let state = match term {
-            &Term::Atom(ref cell, ref atom) =>
-                IteratorState::IsolatedAtom(cell, atom),
-            &Term::Clause(_, _, ref terms) =>
-                IteratorState::RootClause(0, terms),
-            &Term::Var(ref cell, ref var) =>
-                IteratorState::IsolatedVar(cell, var)
-        };
-
-        QueryIterator { state_stack: vec![state] }
-    }
-}
-
-impl<'a> Iterator for QueryIterator<'a> {
-    type Item = TermRef<'a>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        while let Some(iter_state) = self.state_stack.pop() {
-            match iter_state {
-                IteratorState::Atom(lvl, cell, atom) =>
-                    return Some(TermRef::Atom(lvl, cell, atom)),
-                IteratorState::Clause(lvl, child_num, cell, atom, child_terms) => {
-                    if child_num == child_terms.len() {
-                        return Some(TermRef::Clause(lvl, cell, atom, child_terms));
-                    } else {
-                        self.push_clause(lvl, child_num + 1, cell, atom, child_terms);
-                        self.push_subterm(Level::Deep, child_terms[child_num].as_ref());
-                    }
-                },
-                IteratorState::IsolatedAtom(cell, atom) =>
-                    return Some(TermRef::Atom(Level::Shallow, cell, atom)),
-                IteratorState::IsolatedVar(cell, var) =>
-                    return Some(TermRef::Var(Level::Shallow, cell, var)),
-                IteratorState::RootClause(child_num, child_terms) => {
-                    if child_num == child_terms.len() {
-                        return None;
-                    } else {
-                        self.push_root_clause(child_num + 1, child_terms);
-                        self.push_subterm(Level::Shallow, child_terms[child_num].as_ref());
-                    }
-                },
-                IteratorState::Var(lvl, cell, var) =>
-                    return Some(TermRef::Var(lvl, cell, var))
-            };
-        }
-
-        None
-    }
-}
-
-pub struct FactIterator<'a> {
-    state_queue: VecDeque<IteratorState<'a>>,
-}
-
-impl<'a> FactIterator<'a> {
-    fn push_subterm(&mut self, lvl: Level, term: &'a Term) {
-        self.state_queue.push_back(IteratorState::to_state(lvl, term));
-    }
-
-    fn new(term: &'a Term) -> FactIterator<'a> {
-        let states = match term {
-            &Term::Atom(ref cell, ref atom) =>
-                vec![IteratorState::IsolatedAtom(cell, atom)],
-            &Term::Clause(_, _, ref terms) =>
-                vec![IteratorState::RootClause(0, terms)],
-            &Term::Var(ref cell, ref var) =>
-                vec![IteratorState::IsolatedVar(cell, var)]
-        };
-
-        FactIterator { state_queue:  VecDeque::from(states) }
-    }
-}
-
-impl<'a> Iterator for FactIterator<'a> {
-    type Item = TermRef<'a>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        while let Some(state) = self.state_queue.pop_front() {
-            match state {
-                IteratorState::Atom(lvl, cell, atom) =>
-                    return Some(TermRef::Atom(lvl, cell, atom)),
-                IteratorState::Clause(lvl, _, cell, atom, child_terms) => {
-                    for child_term in child_terms {
-                        self.push_subterm(Level::Deep, child_term);
-                    }
-
-                    return Some(TermRef::Clause(lvl, cell, atom, child_terms));
-                },
-                IteratorState::IsolatedAtom(cell, atom) =>
-                    return Some(TermRef::Atom(Level::Shallow, cell, atom)),
-                IteratorState::IsolatedVar(cell, var) =>
-                    return Some(TermRef::Var(Level::Shallow, cell, var)),
-                IteratorState::RootClause(_, child_terms) => {
-                    for child_term in child_terms {
-                        self.push_subterm(Level::Shallow, child_term);
-                    }
-                },
-                IteratorState::Var(lvl, cell, var) =>
-                    return Some(TermRef::Var(lvl, cell, var))
-            }
-        }
-
-        None
-    }
-}
-
-impl Term {
-    pub fn post_order_iter(&self) -> QueryIterator {
-        QueryIterator::new(self)
-    }
-
-    pub fn breadth_first_iter(&self) -> FactIterator {
-        FactIterator::new(self)
-    }
-}

src/l2/l2_parser.lalrpop

@@ -1,45 +0,0 @@
-use l2::ast::*;
-
-use std::cell::Cell;
-
-grammar;
-
-pub TopLevel: TopLevel = {
-    "?-" <t:Term> "." => TopLevel::Query(t),
-    <r:Rule> "."      => TopLevel::Rule(r),
-    <t:Term> "."      => TopLevel::Fact(t),
-};
-
-Atom : Atom = {
-    r"[a-z][a-z0-9_]*" => <>.trim().to_string(),
-};
-
-BoxedTerm : Box<Term> = {
-    <t:Term> => Box::new(t),
-};
-
-Clause : Term = {
-    <a:Atom> "(" <ts: (<BoxedTerm> ",")*> <t:BoxedTerm> ")" => {
-     	let mut ts = ts;
-     	ts.push(t);
-	Term::Clause(Cell::new(RegType::Temp(0)), a, ts)
-    },
-};
-
-Rule : Rule = {
-    <c:Clause> ":-" <h:Term> <cs: ("," <Term>)*> =>
-         Rule { head: (c, h), clauses: cs },
-    <a:Atom> ":-" <h:Term> <cs: ("," <Term>)*> =>
-         Rule { head: (Term::Atom(Cell::new(RegType::Temp(0)), a), h),
-	        clauses: cs }
-};
-
-Term : Term = {
-    <Clause> => <>,
-    <Atom> => Term::Atom(Cell::new(RegType::Temp(0)), <>),
-    <Var>  => Term::Var(Cell::new(VarReg::Norm(RegType::Temp(0))), <>),
-};
-
-Var : Var = {
-    r"[A-Z][a-z0-9_]*" => <>.trim().to_string(),
-};

src/l2/machine.rs

@@ -1,456 +0,0 @@
-use l2::ast::*;
-use l2::codegen::*;
-use l2::heapview::*;
-use l2::stack::*;
-
-use std::collections::HashMap;
-use std::vec::Vec;
-
-#[derive(Clone, Copy)]
-enum MachineMode {
-    Read,
-    Write
-}
-
-struct MachineState {
-    h: usize,
-    s: usize,
-    p: CodePtr,
-    cp: CodePtr,
-    fail: bool,
-    heap: Heap,
-    mode: MachineMode,
-    stack: Stack,
-    registers: Registers
-}
-
-type CodeDir = HashMap<(Atom, usize), usize>;
-
-pub struct Machine {
-    ms: MachineState,
-    code: Code,
-    code_dir: CodeDir
-}
-
-impl Machine {
-    pub fn new() -> Self {
-        Machine {
-            ms: MachineState::new(),
-            code: Vec::new(),
-            code_dir: HashMap::new()
-        }
-    }
-
-    pub fn failed(&self) -> bool {
-        self.ms.fail
-    }
-
-    pub fn add_fact(&mut self, fact: &Term, mut code: Code) {
-        let p = self.code.len();
-        let name  = fact.name().clone();
-        let arity = fact.arity();
-
-        self.code.append(&mut code);
-        self.code_dir.insert((name, arity), p);
-    }
-
-    pub fn add_rule(&mut self, rule: &Rule, mut code: Code) {
-        let p = self.code.len();
-        let name  = rule.head.0.name().clone();
-        let arity = rule.head.0.arity();
-
-        self.code.append(&mut code);
-        self.code_dir.insert((name, arity), p);
-    }
-
-    fn execute_instr(&mut self, instr: &Line) -> bool {
-        let mut instr = instr;
-
-        loop {
-            match instr {
-                &Line::Fact(ref fact) => {
-                    for fact_instr in fact {
-                        self.ms.execute_fact_instr(&fact_instr);
-                    }
-                    self.ms.p += 1;
-                },
-                &Line::Query(ref query) => {
-                    for query_instr in query {
-                        self.ms.execute_query_instr(&query_instr);
-                    }
-                    self.ms.p += 1;
-                },
-                &Line::Control(ref control_instr) =>
-                    self.ms.execute_ctrl_instr(&self.code_dir, control_instr),
-            }
-
-            if self.failed() {
-                return false;
-            }
-
-            match self.ms.p {
-                CodePtr::DirEntry(p) if p < self.code.len() =>
-                    instr = &self.code[p],
-                _ => break
-            }
-        }
-
-        true
-    }
-
-    fn heap_view(&self, var_dir: HashMap<&Var, HeapCellRef>) -> String {
-        let mut result = String::new();
-
-        for (var, hcr) in var_dir {
-            let mut arities = Vec::new();
-            let viewer = HeapCellViewer::new(&self.ms.heap, hcr.heap_offset());
-
-            if result != "" {
-                result += "\n";
-            }
-
-            result += var.as_str();
-            result += " = ";
-
-            for view in viewer {
-                match arities.pop() {
-                    Some(n) => arities.push(n-1),
-                    None => {}
-                }
-
-                if !(arities.is_empty() || result.ends_with("(")) {
-                    result += ", ";
-                }
-
-                match view {
-                    HeapCellView::Str(arity, ref name) => {
-                        result += name.as_str();
-
-                        if arity > 0 {
-                            arities.push(arity);
-                            result += "(";
-                        }
-                    },
-                    HeapCellView::Var(cell_num) => {
-                        result += "_";
-                        result += cell_num.to_string().as_str();
-                    }
-                }
-
-                while let Some(&0) = arities.last() {
-                    result += ")";
-                    arities.pop();
-                }
-            }
-        }
-
-        result
-    }
-
-    pub fn run_query(&mut self, code: Code, cg: &CodeGenerator) -> Option<String>
-    {
-        let mut succeeded = true;
-
-        for instr in code.iter().take(1) {
-            succeeded = self.execute_instr(&instr);
-        }
-
-        let mut heap_locs = HashMap::new();
-
-        if succeeded {            
-            for (var, vr) in cg.vars() {
-                let hcr = self.ms.registers[vr.root_register()];
-                heap_locs.insert(*var, hcr);
-            }
-
-            for instr in code.iter().skip(1) {
-                succeeded = self.execute_instr(&instr);
-                if !succeeded {
-                    break;
-                }
-            }
-        }
-        
-        if succeeded {
-            Some(self.heap_view(heap_locs))
-        } else {
-            None
-        }   
-    }
-
-    pub fn reset(&mut self) {
-        self.ms.reset();
-    }
-}
-
-impl MachineState {
-    fn new() -> MachineState {
-        MachineState { h: 0,
-                       s: 0,
-                       p: CodePtr::TopLevel,
-                       cp: CodePtr::TopLevel,
-                       fail: false,
-                       heap: Vec::with_capacity(256),
-                       mode: MachineMode::Write,
-                       stack: Stack::new(),
-                       registers: vec![HeapCellRef::Ref(0); 32] }
-    }
-
-    fn register_mut(&mut self, r: RegType) -> &mut HeapCellRef {
-        match r {
-            RegType::Temp(r) => &mut self.registers[r],
-            RegType::Perm(r) => &mut self.stack[r]
-        }
-    }
-
-    fn lookup(&self, a: Addr) -> HeapCellRef {
-        match a {
-            Addr::HeapCell(r)  => self.heap[r].as_ref(r),
-            Addr::RegNum(r)    => self.registers[r],
-            Addr::StackCell(s) => self.stack[s]
-        }
-    }
-
-    fn deref(&self, a: Addr) -> Addr {
-        let mut a = a;
-
-        loop {
-            if let HeapCellRef::Ref(value) = self.lookup(a) {
-                if let Addr::HeapCell(av) = a {
-                    if value != av {
-                        a = Addr::HeapCell(value);
-                        continue;
-                    }
-                } else {
-                    a = Addr::HeapCell(value);
-                    continue;
-                }
-            }
-
-            return a;
-        };
-    }
-
-    fn is_unbound(hc: &HeapCellValue, index: usize) -> bool {
-        match hc {
-            &HeapCellValue::Ref(r) => r == index,
-            _ => false
-        }
-    }
-
-    fn bind(&mut self, a: Addr, val: usize) {
-        let mut a = a;
-
-        loop {
-            match a {
-                addr @ Addr::RegNum(_) | addr @ Addr::StackCell(_) => {
-                    if let HeapCellRef::Ref(hc) = self.lookup(addr) {
-                        a = Addr::HeapCell(hc);
-                    } else if Self::is_unbound(&self.heap[val], val) {
-                        self.heap[val] = HeapCellValue::from(self.lookup(addr));
-                        break;
-                    } else {
-                        self.fail = true;
-                        break;
-                    }
-                },
-                Addr::HeapCell(hc) => {
-                    if Self::is_unbound(&self.heap[hc], hc) {
-                        self.heap[hc] = HeapCellValue::Ref(val);
-                        break;
-                    } else if Self::is_unbound(&self.heap[val], val) {
-                        self.heap[val] = HeapCellValue::Ref(hc);
-                        break;
-                    } else {
-                        self.fail = true;
-                        break;
-                    }
-                }
-            };
-        }
-    }
-
-    fn unify(&mut self, a1: Addr, a2: Addr) {
-        let mut pdl = vec![a1, a2];
-
-        self.fail = false;
-
-        while !(pdl.is_empty() || self.fail) {
-            let d1 = self.deref(pdl.pop().unwrap());
-            let d2 = self.deref(pdl.pop().unwrap());
-
-            if d1 != d2 {
-                match (self.lookup(d1), self.lookup(d2)) {
-                    (HeapCellRef::Ref(hc), _) =>
-                        self.bind(d2, hc),
-                    (_, HeapCellRef::Ref(hc)) =>
-                        self.bind(d1, hc),
-                    (HeapCellRef::Str(a1), HeapCellRef::Str(a2)) => {
-                        let r1 = &self.heap[a1];
-                        let r2 = &self.heap[a2];
-
-                        if let &HeapCellValue::NamedStr(n1, ref f1) = r1 {
-                            if let &HeapCellValue::NamedStr(n2, ref f2) = r2 {
-                                if n1 == n2 && *f1 == *f2 {
-                                    for i in 1 .. n1 + 1 {
-                                        pdl.push(Addr::HeapCell(a1 + i));
-                                        pdl.push(Addr::HeapCell(a2 + i));
-                                    }
-
-                                    continue;
-                                }
-                            }
-                        }
-
-                        self.fail = true;
-                    },
-                };
-            }
-        }
-    }
-
-    fn execute_query_instr(&mut self, instr: &QueryInstruction) {
-        match instr {
-            &QueryInstruction::PutStructure(_, ref name, arity, reg) => {
-                self.heap.push(HeapCellValue::Str(self.h + 1));
-                self.heap.push(HeapCellValue::NamedStr(arity, name.clone()));
-
-                *self.register_mut(reg) = HeapCellRef::Str(self.h + 1);
-
-                self.h += 2;
-            },
-            &QueryInstruction::PutValue(norm, arg) =>
-                self.registers[arg] = match norm {
-                    RegType::Temp(reg) => self.registers[reg],
-                    RegType::Perm(reg) => self.stack[reg]
-                },
-            &QueryInstruction::PutVariable(norm, arg) => {
-                self.heap.push(HeapCellValue::Ref(self.h));
-
-                *self.register_mut(norm) = HeapCellRef::Ref(self.h);
-                self.registers[arg] = HeapCellRef::Ref(self.h);
-
-                self.h += 1;
-            },
-            &QueryInstruction::SetVariable(reg) => {
-                self.heap.push(HeapCellValue::Ref(self.h));
-                *self.register_mut(reg) = HeapCellRef::Ref(self.h);
-
-                self.h += 1;
-            },
-            &QueryInstruction::SetValue(reg) => {
-                let heap_val = self.lookup(Addr::from(reg));
-                self.heap.push(HeapCellValue::from(heap_val));
-
-                self.h += 1;
-            },
-        }
-    }
-
-    fn execute_fact_instr(&mut self, instr: &FactInstruction) {
-        match instr {
-            &FactInstruction::GetStructure(_, ref name, arity, reg) => {
-                let addr = self.deref(Addr::from(reg));
-
-                match self.lookup(addr) {
-                    HeapCellRef::Str(a) => {
-                        let result = &self.heap[a];
-
-                        if let &HeapCellValue::NamedStr(narity, ref str) = result {
-                            if narity == arity && *name == *str {
-                                self.s = a + 1;
-                                self.mode = MachineMode::Read;
-                            } else {
-                                self.fail = true;
-                            }
-                        }
-                    },
-                    HeapCellRef::Ref(_) => {
-                        self.heap.push(HeapCellValue::Str(self.h + 1));
-                        self.heap.push(HeapCellValue::NamedStr(arity, name.clone()));
-
-                        let h = self.h;
-
-                        self.bind(addr, h);
-
-                        self.h += 2;
-                        self.mode = MachineMode::Write;
-                    }
-                };
-            },
-            &FactInstruction::GetVariable(norm, arg) =>
-                *self.register_mut(norm) = self.registers[arg],
-            &FactInstruction::GetValue(norm, arg) =>
-                self.unify(Addr::from(norm), Addr::RegNum(arg)),
-            &FactInstruction::UnifyVariable(reg) => {
-                match self.mode {
-                    MachineMode::Read  =>
-                        *self.register_mut(reg) = self.heap[self.s].as_ref(self.s),
-                    MachineMode::Write => {
-                        self.heap.push(HeapCellValue::Ref(self.h));
-                        *self.register_mut(reg) = HeapCellRef::Ref(self.h);
-                        self.h += 1;
-                    }
-                };
-
-                self.s += 1;
-            },
-            &FactInstruction::UnifyValue(reg) => {
-                let s = self.s;
-
-                match self.mode {
-                    MachineMode::Read  =>
-                        self.unify(Addr::from(reg), Addr::HeapCell(s)),
-                    MachineMode::Write => {
-                        let heap_val = self.lookup(Addr::from(reg));
-                        self.heap.push(HeapCellValue::from(heap_val));
-                        self.h += 1;
-                    }
-                };
-
-                self.s += 1;
-            }
-        }
-    }
-
-    fn execute_ctrl_instr(&mut self, code_dir: &CodeDir, instr: &ControlInstruction)
-    {
-        match instr {
-            &ControlInstruction::Allocate(num_cells) => {
-                self.stack.push(self.cp, num_cells);
-                self.p += 1;
-            },
-            &ControlInstruction::Call(ref name, arity) => {
-                let compiled_tl_index = code_dir.get(&(name.clone(), arity))
-                                                .map(|index| *index);
-
-                match compiled_tl_index {
-                    Some(compiled_tl_index) => {
-                        self.cp = self.p + 1;
-                        self.p  = CodePtr::DirEntry(compiled_tl_index);
-                    },
-                    None => self.fail = true
-                };
-            },
-            &ControlInstruction::Deallocate => {
-                self.p = self.stack.get_cp();
-                self.stack.pop();
-            },
-            &ControlInstruction::Proceed =>
-                self.p = self.cp,
-        };
-    }
-
-    fn reset(&mut self) {
-        self.h = 0;
-        self.s = 0;
-        self.p = CodePtr::TopLevel;
-        self.cp = CodePtr::TopLevel;
-
-        self.fail = false;
-        self.heap.clear();
-        self.mode = MachineMode::Write;
-        self.stack = Stack::new();
-        self.registers = vec![HeapCellRef::Ref(0); 32];
-    }
-}

src/l2/mod.rs

@@ -1,7 +0,0 @@
-pub mod ast;
-pub mod heapview;
-pub mod iterators;
-pub mod l2_parser;
-pub mod codegen;
-pub mod machine;
-pub mod stack;

src/l2/stack.rs

@@ -1,60 +0,0 @@
-use l2::ast::*;
-
-use std::ops::{Index, IndexMut};
-use std::vec::Vec;
-
-struct Frame {
-    cp: CodePtr,
-    perms: Vec<HeapCellRef>
-}
-
-impl Frame {
-    fn new(cp: CodePtr, n: usize) -> Self {
-        Frame {
-            cp: cp,
-            perms: vec![HeapCellRef::Ref(0); n]
-        }
-    }
-
-    fn read_pv(&self, i: usize) -> &HeapCellRef {
-        self.perms.index(i)
-    }
-
-    fn read_pv_mut(&mut self, i: usize) -> &mut HeapCellRef {
-        self.perms.index_mut(i)
-    }
-}
-
-pub struct Stack(Vec<Frame>);
-
-impl Stack {
-    pub fn new() -> Self {
-        Stack(Vec::new())
-    }
-    
-    pub fn push(&mut self, cp: CodePtr, n: usize) {
-        self.0.push(Frame::new(cp, n));
-    }
-
-    pub fn get_cp(&self) -> CodePtr {
-        self.0.last().unwrap().cp
-    }
-    
-    pub fn pop(&mut self) {
-        self.0.pop();
-    }
-}
-
-impl Index<usize> for Stack {
-    type Output = HeapCellRef;
-
-    fn index(&self, index: usize) -> &Self::Output {
-        self.0.last().unwrap().read_pv(index - 1)
-    }
-}
-
-impl IndexMut<usize> for Stack {
-    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
-        self.0.last_mut().unwrap().read_pv_mut(index - 1)
-    }
-}

src/l3/and_stack.rs

@@ -1,80 +0,0 @@
-use l3::ast::*;
-
-use std::ops::{Index, IndexMut};
-use std::vec::Vec;
-
-pub struct Frame {
-    pub global_index: usize,
-    pub e: usize,
-    pub cp: CodePtr,
-    perms: Vec<Addr>
-}
-
-impl Frame {
-    fn new(global_index: usize, e: usize, cp: CodePtr, n: usize) -> Self {
-        Frame {
-            global_index: global_index,
-            e: e,
-            cp: cp,
-            perms: vec![Addr::HeapCell(0); n]
-        }
-    }
-}
-
-pub struct AndStack(Vec<Frame>);
-
-impl AndStack {
-    pub fn new() -> Self {
-        AndStack(Vec::new())
-    }
-
-    pub fn push(&mut self, global_index: usize, e: usize, cp: CodePtr, n: usize) {
-        self.0.push(Frame::new(global_index, e, cp, n));
-    }
-
-    pub fn top(&self) -> Option<&Frame> {
-        self.0.last()
-    }
-
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    pub fn clear(&mut self) {
-        self.0.clear()
-    }
-
-    // drop the last n frames.
-    pub fn drop_frames(&mut self, n: usize) {
-        let len = self.0.len();
-        self.0.truncate(len - n);
-    }
-}
-
-impl Index<usize> for AndStack {
-    type Output = Frame;
-
-    fn index(&self, index: usize) -> &Self::Output {
-        self.0.index(index)
-    }
-}
-
-impl IndexMut<usize> for AndStack {
-    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
-        self.0.index_mut(index)
-    }
-}
-
-impl Index<usize> for Frame {
-    type Output = Addr;
-
-    fn index(&self, index: usize) -> &Self::Output {
-        self.perms.index(index - 1)
-    }
-}
-
-impl IndexMut<usize> for Frame {
-    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
-        self.perms.index_mut(index - 1)
-    }
-}

src/l3/ast.rs

@@ -1,303 +0,0 @@
-use std::cell::Cell;
-use std::collections::HashMap;
-use std::ops::{Add, AddAssign};
-use std::vec::Vec;
-
-pub type Var = String;
-
-pub type Atom = String;
-
-pub enum PredicateClause {
-    Fact(Term),
-    Rule(Rule)
-}
-
-impl PredicateClause {
-    pub fn name(&self) -> &Atom {
-        match self {
-            &PredicateClause::Fact(ref t) => t.name(),
-            &PredicateClause::Rule(ref rule) => rule.head.0.name()
-        }
-    }
-
-    pub fn arity(&self) -> usize {
-        match self {
-            &PredicateClause::Fact(ref t) => t.arity(),
-            &PredicateClause::Rule(ref rule) => rule.head.0.arity()
-        }
-    }
-}
-
-pub enum TopLevel {
-    Fact(Term),
-    Predicate(Vec<PredicateClause>),
-    Query(Term),
-    Rule(Rule)
-}
-
-#[derive(Clone, Copy)]
-pub enum Level {
-    Deep, Shallow
-}
-
-#[derive(Clone, Copy)]
-pub enum RegType {
-    Perm(usize),
-    Temp(usize)
-}
-
-impl RegType {
-    pub fn reg_num(self) -> usize {
-        match self {
-            RegType::Perm(reg_num) | RegType::Temp(reg_num) => reg_num
-        }
-    }
-
-    pub fn is_perm(self) -> bool {
-        match self {
-            RegType::Perm(_) => true,
-            _ => false
-        }
-    }
-}
-
-#[derive(Clone, Copy)]
-pub enum VarReg {
-    ArgAndNorm(RegType, usize),
-    Norm(RegType)
-}
-
-impl VarReg {
-    pub fn norm(self) -> RegType {
-        match self {
-            VarReg::ArgAndNorm(reg, _) | VarReg::Norm(reg) => reg
-        }
-    }
-
-    pub fn root_register(self) -> usize {
-        match self {
-            VarReg::ArgAndNorm(_, root) => root,
-            VarReg::Norm(root) => root.reg_num()
-        }
-    }
-}
-
-pub enum Term {
-    Atom(Cell<RegType>, Atom),
-    Clause(Cell<RegType>, Atom, Vec<Box<Term>>),
-    Var(Cell<VarReg>, Var)
-}
-
-pub struct Rule {
-    pub head: (Term, Term),
-    pub clauses: Vec<Term>
-}
-
-pub enum TermRef<'a> {
-    Atom(Level, &'a Cell<RegType>, &'a Atom),
-    Clause(Level, &'a Cell<RegType>, &'a Atom, &'a Vec<Box<Term>>),
-    Var(Level, &'a Cell<VarReg>, &'a Var)
-}
-
-pub enum FactInstruction {
-    GetStructure(Level, Atom, usize, RegType),
-    GetValue(RegType, usize),
-    GetVariable(RegType, usize),
-    UnifyVariable(RegType),
-    UnifyValue(RegType)
-}
-
-pub enum QueryInstruction {
-    PutStructure(Level, Atom, usize, RegType),
-    PutValue(RegType, usize),
-    PutVariable(RegType, usize),
-    SetVariable(RegType),
-    SetValue(RegType)
-}
-
-pub enum ChoiceInstruction {
-    RetryMeElse(usize),
-    TrustMe,
-    TryMeElse(usize)
-}
-
-pub enum ControlInstruction {
-    Allocate(usize),
-    Call(Atom, usize),
-    Deallocate,
-    Proceed
-}
-
-pub type CompiledFact = Vec<FactInstruction>;
-
-pub type CompiledQuery = Vec<QueryInstruction>;
-
-pub enum Line {
-    Choice(ChoiceInstruction),
-    Control(ControlInstruction),
-    Fact(CompiledFact),
-    Query(CompiledQuery)
-}
-
-pub enum LineOrCodeOffset<'a> {
-    Instruction(&'a Line),
-    Offset(usize)
-}
-
-impl<'a> From<&'a Line> for LineOrCodeOffset<'a> {
-    fn from(line: &'a Line) -> Self {
-        LineOrCodeOffset::Instruction(line)
-    }
-}
-
-pub type Code = Vec<Line>;
-
-#[derive(Clone, Copy, PartialEq)]
-pub enum Addr {
-    HeapCell(usize),
-    StackCell(usize, usize),
-    Str(usize)
-}
-
-impl Addr {
-    pub fn is_ref(self) -> bool {
-        match self {
-            Addr::HeapCell(_) | Addr::StackCell(_, _) => true,
-            _ => false
-        }
-    }
-
-    pub fn as_ref(self) -> Option<Ref> {
-        match self {
-            Addr::HeapCell(hc) => Some(Ref::HeapCell(hc)),
-            Addr::StackCell(fr, sc) => Some(Ref::StackCell(fr, sc)),
-            _ => None
-        }
-    }
-}
-
-impl From<Ref> for Addr {
-    fn from(r: Ref) -> Self {
-        match r {
-            Ref::HeapCell(hc) => Addr::HeapCell(hc),
-            Ref::StackCell(fr, sc) => Addr::StackCell(fr, sc)
-        }
-    }
-}
-
-#[derive(Clone, Copy, PartialEq)]
-pub enum Ref {
-    HeapCell(usize),
-    StackCell(usize, usize)
-}
-
-#[derive(Clone, PartialEq)]
-pub enum HeapCellValue {
-    NamedStr(usize, Atom),
-    Ref(Ref),
-    Str(usize)
-}
-
-impl From<Addr> for HeapCellValue {
-    fn from(addr: Addr) -> HeapCellValue {
-        match addr {
-            Addr::HeapCell(hc) =>
-                HeapCellValue::Ref(Ref::HeapCell(hc)),
-            Addr::StackCell(fr, sc) =>
-                HeapCellValue::Ref(Ref::StackCell(fr, sc)),
-            Addr::Str(hc) =>
-                HeapCellValue::Str(hc)
-        }
-    }
-}
-
-impl HeapCellValue {
-    pub fn as_addr(&self, focus: usize) -> Addr {
-        match self {           
-            &HeapCellValue::Ref(r) => Addr::from(r),
-            &HeapCellValue::Str(s) => Addr::Str(s),
-            &HeapCellValue::NamedStr(_, _) => Addr::Str(focus)
-        }
-    }
-}
-
-#[derive(Clone, Copy)]
-pub enum CodePtr {
-    DirEntry(usize),
-    TopLevel
-}
-
-impl Default for CodePtr {
-    fn default() -> Self {
-        CodePtr::TopLevel
-    }
-}
-
-impl Add<usize> for CodePtr {
-    type Output = CodePtr;
-
-    fn add(self, rhs: usize) -> Self::Output {
-        match self {
-            CodePtr::DirEntry(p) => CodePtr::DirEntry(p + rhs),
-            CodePtr::TopLevel => CodePtr::TopLevel
-        }
-    }
-}
-
-impl AddAssign<usize> for CodePtr {
-    fn add_assign(&mut self, rhs: usize) {
-        match self {
-            &mut CodePtr::DirEntry(ref mut p) => *p += rhs,
-            _ => {}
-        }
-    }
-}
-
-pub type Heap = Vec<HeapCellValue>;
-
-pub type Registers = Vec<Addr>;
-
-impl Term {
-    pub fn subterms(&self) -> usize {
-        match self {
-            &Term::Clause(_, _, ref terms) => terms.len(),
-            _ => 1
-        }
-    }
-
-    pub fn name(&self) -> &Atom {
-        match self {
-            &Term::Atom(_, ref atom)
-            | &Term::Var(_, ref atom)
-            | &Term::Clause(_, ref atom, _) => atom
-        }
-    }
-
-    pub fn arity(&self) -> usize {
-        match self {
-            &Term::Atom(_, _) | &Term::Var(_, _) => 0,
-            &Term::Clause(_, _, ref child_terms) => child_terms.len()
-        }
-    }
-}
-
-pub type HeapVarDict = HashMap<Var, Addr>;
-
-pub enum EvalResult {
-    EntryFailure,
-    EntrySuccess,
-    InitialQuerySuccess(HeapVarDict),
-    QueryFailure,
-    SubsequentQuerySuccess,
-}
-
-impl EvalResult {
-    #[allow(dead_code)]
-    pub fn failed_query(&self) -> bool {
-        if let &EvalResult::QueryFailure = self {
-            true
-        } else {
-            false
-        }
-    }
-}

src/l3/codegen.rs

@@ -1,447 +0,0 @@
-use l3::ast::*;
-use l3::iterators::{FactIterator, QueryIterator};
-
-use std::cell::Cell;
-use std::cmp::max;
-use std::collections::HashMap;
-use std::vec::Vec;
-
-trait CompilationTarget<'a> {
-    type Iterator : Iterator<Item=TermRef<'a>>;
-
-    fn iter(&'a Term) -> Self::Iterator;
-
-    fn to_structure(Level, Atom, usize, RegType) -> Self;
-
-    fn argument_to_variable(RegType, usize) -> Self;
-    fn argument_to_value(RegType, usize) -> Self;
-    fn subterm_to_variable(RegType) -> Self;
-    fn subterm_to_value(RegType) -> Self;
-
-    fn clause_arg_to_instr(RegType) -> Self;
-}
-
-impl<'a> CompilationTarget<'a> for FactInstruction {
-    type Iterator = FactIterator<'a>;
-
-    fn iter(term: &'a Term) -> Self::Iterator {
-        term.breadth_first_iter()
-    }
-
-    fn to_structure(lvl: Level, atom: Atom, arity: usize, reg: RegType) -> Self {
-        FactInstruction::GetStructure(lvl, atom, arity, reg)
-    }
-
-    fn argument_to_variable(arg: RegType, val: usize) -> Self {
-        FactInstruction::GetVariable(arg, val)
-    }
-
-    fn argument_to_value(arg: RegType, val: usize) -> Self {
-        FactInstruction::GetValue(arg, val)
-    }
-
-    fn subterm_to_variable(val: RegType) -> Self {
-        FactInstruction::UnifyVariable(val)
-    }
-
-    fn subterm_to_value(val: RegType) -> Self {
-        FactInstruction::UnifyValue(val)
-    }
-
-    fn clause_arg_to_instr(val: RegType) -> Self {
-        FactInstruction::UnifyVariable(val)
-    }
-}
-
-impl<'a> CompilationTarget<'a> for QueryInstruction {
-    type Iterator = QueryIterator<'a>;
-
-    fn iter(term: &'a Term) -> Self::Iterator {
-        term.post_order_iter()
-    }
-
-    fn to_structure(lvl: Level, atom: Atom, arity: usize, reg: RegType) -> Self {
-        QueryInstruction::PutStructure(lvl, atom, arity, reg)
-    }
-
-    fn argument_to_variable(arg: RegType, val: usize) -> Self {
-        QueryInstruction::PutVariable(arg, val)
-    }
-
-    fn argument_to_value(arg: RegType, val: usize) -> Self {
-        QueryInstruction::PutValue(arg, val)
-    }
-
-    fn subterm_to_variable(val: RegType) -> Self {
-        QueryInstruction::SetVariable(val)
-    }
-
-    fn subterm_to_value(val: RegType) -> Self {
-        QueryInstruction::SetValue(val)
-    }
-
-    fn clause_arg_to_instr(val: RegType) -> Self {
-        QueryInstruction::SetValue(val)
-    }
-}
-
-struct TermMarker<'a> {
-    bindings: HashMap<&'a Var, VarReg>,
-    arg_c:    usize,
-    perm_c:   usize,
-    temp_c:   usize
-}
-
-impl<'a> TermMarker<'a> {
-    fn new() -> TermMarker<'a> {
-        TermMarker { bindings: HashMap::new(),
-                     arg_c:    1,
-                     perm_c:   1,
-                     temp_c:   1 }
-    }
-
-    fn reset(&mut self) {
-        self.bindings.clear();
-        self.perm_c = 1;
-    }
-    
-    fn contains_var(&self, var: &'a Var) -> bool {
-        self.bindings.contains_key(var)
-    }
-
-    fn get(&self, var: &'a Var) -> VarReg {
-        *self.bindings.get(var).unwrap()
-    }
-
-    fn insert(&mut self, var: &'a Var, r: VarReg) {
-        self.bindings.insert(var, r);
-    }
-
-    fn mark_non_var(&mut self, lvl: Level, cell: &Cell<RegType>) {
-        let reg_type = cell.get();
-
-        if reg_type.reg_num() == 0 {
-            match lvl {
-                Level::Deep if reg_type.is_perm() => {
-                    let perm = self.perm_c;
-                    self.perm_c += 1;
-                    cell.set(RegType::Perm(perm));
-                },
-                Level::Deep => {
-                    let temp = self.temp_c;
-                    self.temp_c += 1;
-                    cell.set(RegType::Temp(temp));
-                },
-                Level::Shallow if reg_type.is_perm() => {
-                    let arg = self.arg_c;
-                    self.arg_c += 1;
-                    cell.set(RegType::Perm(arg));
-                },
-                Level::Shallow => {
-                    let arg = self.arg_c;
-                    self.arg_c += 1;
-                    cell.set(RegType::Temp(arg));
-                }
-            };
-        }
-    }
-
-    fn mark_old_var(&mut self, lvl: Level, var: &'a Var) -> VarReg
-    {
-        let reg = self.get(var);
-
-        match lvl {
-            Level::Deep => VarReg::Norm(reg.norm()),
-            Level::Shallow => {
-                let reg = VarReg::ArgAndNorm(reg.norm(), self.arg_c);
-
-                self.arg_c += 1;
-                self.insert(var, reg);
-
-                reg
-            }
-        }
-    }
-
-    fn mark_new_var(&mut self, lvl: Level, var: &'a Var, reg: RegType) -> VarReg
-    {
-        let inner_reg = if reg.is_perm() {
-            let perm = self.perm_c;
-            self.perm_c += 1;
-            RegType::Perm(perm)
-        } else {
-            let temp = self.temp_c;
-            self.temp_c += 1;
-            RegType::Temp(temp)
-        };
-
-        let reg = match lvl {
-            Level::Deep => VarReg::Norm(inner_reg),
-            Level::Shallow => {
-                let reg = VarReg::ArgAndNorm(inner_reg, self.arg_c);
-                self.arg_c += 1;
-                reg
-            }
-        };
-
-        self.insert(var, reg);
-        reg
-    }
-
-    fn advance_at_head(&mut self, term: &'a Term) {
-        self.arg_c = 1;
-        self.temp_c = max(term.subterms(), self.temp_c) + 1;
-    }
-
-    fn advance(&mut self, term: &'a Term) {
-        self.arg_c = 1;
-        self.temp_c = term.subterms() + 1;
-    }
-}
-
-#[derive(Copy, Clone)]
-enum TermStatus {
-    New, Old, Recurrent
-}
-
-pub struct CodeGenerator<'a> {
-    marker: TermMarker<'a>
-}
-
-type VariableFixture<'a>  = (TermStatus, Vec<&'a Cell<VarReg>>);
-type VariableFixtures<'a> = HashMap<&'a Var, VariableFixture<'a>>;
-
-impl<'a> CodeGenerator<'a> {
-    pub fn new() -> Self {
-        CodeGenerator { marker: TermMarker::new() }
-    }
-
-    pub fn vars(&self) -> &HashMap<&Var, VarReg> {
-        &self.marker.bindings
-    }
-
-    fn to_structure<Target>(&mut self,
-                            lvl: Level,
-                            name: &'a Atom,
-                            cell: &'a Cell<RegType>,
-                            arity: usize)
-                            -> Target
-        where Target: CompilationTarget<'a>
-    {
-        self.marker.mark_non_var(lvl, cell);
-        Target::to_structure(lvl, name.clone(), arity, cell.get())
-    }
-
-    fn var_term<Target>(&mut self,
-                        lvl: Level,
-                        cell: &'a Cell<VarReg>,
-                        var: &'a Var)
-                        -> Target
-        where Target: CompilationTarget<'a>
-    {
-        if !self.marker.contains_var(var) {
-            let reg = self.marker.mark_new_var(lvl, var, cell.get().norm());
-            cell.set(reg);
-
-            match reg {
-                VarReg::ArgAndNorm(arg, norm) =>
-                    Target::argument_to_variable(arg, norm),
-                VarReg::Norm(norm) =>
-                    Target::subterm_to_variable(norm)
-            }
-        } else {
-            let reg = self.marker.mark_old_var(lvl, var);
-            cell.set(reg);
-
-            match reg {
-                VarReg::ArgAndNorm(arg, norm) =>
-                    Target::argument_to_value(arg, norm),
-                VarReg::Norm(norm) =>
-                    Target::subterm_to_value(norm)
-            }
-        }
-    }
-
-    fn non_var_subterm<Target>(&mut self, cell: &'a Cell<RegType>) -> Target
-        where Target: CompilationTarget<'a>
-    {
-        self.marker.mark_non_var(Level::Deep, cell);
-        Target::clause_arg_to_instr(cell.get())
-    }
-
-    fn subterm_to_instr<Target>(&mut self, subterm: &'a Term) -> Target
-        where Target: CompilationTarget<'a>
-    {
-        match subterm {
-            &Term::Atom(ref cell, _) | &Term::Clause(ref cell, _, _) =>
-                self.non_var_subterm(cell),
-            &Term::Var(ref cell, ref var) =>
-                self.var_term(Level::Deep, cell, var)
-        }
-    }
-
-    fn compile_target<Target>(&mut self, term: &'a Term) -> Vec<Target>
-        where Target: CompilationTarget<'a>
-    {
-        let iter       = Target::iter(term);
-        let mut target = Vec::new();
-
-        for term in iter {
-            match term {
-                TermRef::Atom(lvl, term, atom) =>
-                    target.push(self.to_structure(lvl, atom, term, 0)),
-                TermRef::Clause(lvl, term, atom, terms) => {
-                    target.push(self.to_structure(lvl, atom, term, terms.len()));
-
-                    for subterm in terms {
-                        target.push(self.subterm_to_instr(subterm.as_ref()));
-                    }
-                },
-                TermRef::Var(lvl @ Level::Shallow, ref cell, ref var) =>
-                    target.push(self.var_term(lvl, cell, var)),
-                _ => {}
-            };
-        }
-
-        target
-    }
-
-    fn mark_vars_in_term<Iter>(iter: Iter, vs: &mut VariableFixtures<'a>)
-        where Iter : Iterator<Item=TermRef<'a>>
-    {
-        for term in iter {
-            if let TermRef::Var(_, reg_cell, var) = term {
-                let mut status = vs.entry(var)
-                                   .or_insert((TermStatus::New, Vec::new()));
-
-                status.1.push(reg_cell);
-
-                match status.0 {
-                    TermStatus::Old => status.0 = TermStatus::Recurrent,
-                    _ => {}
-                };
-            }
-        }
-
-        for &mut (ref mut term_status, ref mut cb) in vs.values_mut() {
-            match *term_status {
-                TermStatus::New => *term_status = TermStatus::Old,
-                TermStatus::Recurrent => {
-                    for cell_reg in cb.drain(0..) {
-                        cell_reg.set(VarReg::Norm(RegType::Perm(0)));
-                    }
-                },
-                _ => {}
-            }
-        }
-    }
-
-    fn mark_perm_vars(rule: &'a Rule) -> VariableFixtures {
-        let &Rule { head: (ref p0, ref p1), ref clauses } = rule;
-        let mut vfs = HashMap::new();
-
-        let iter = p0.breadth_first_iter().chain(p1.breadth_first_iter());
-
-        Self::mark_vars_in_term(iter, &mut vfs);
-
-        for term in clauses {
-            Self::mark_vars_in_term(term.breadth_first_iter(), &mut vfs);
-        }
-
-        vfs
-    }
-
-    fn add_conditional_call(compiled_query: &mut Code, term: &Term) {
-        match term {
-            &Term::Atom(_, ref atom) => {
-                let call = ControlInstruction::Call(atom.clone(), 0);
-                compiled_query.push(Line::Control(call));
-            },
-            &Term::Clause(_, ref atom, ref terms) => {
-                let call = ControlInstruction::Call(atom.clone(), terms.len());
-                compiled_query.push(Line::Control(call));
-            },
-            _ => {}
-        }
-    }
-
-    pub fn compile_rule(&mut self, rule: &'a Rule) -> Code {
-        let vfs = Self::mark_perm_vars(&rule);
-        let &Rule { head: (ref p0, ref p1), ref clauses } = rule;
-        let mut perm_vars = 0;
-
-        for &(term_status, _) in vfs.values() {
-            if let TermStatus::Recurrent = term_status {
-                perm_vars += 1;
-            }
-        }
-
-        let mut body = Vec::new();
-
-        body.push(Line::Control(ControlInstruction::Allocate(perm_vars)));
-
-        self.marker.advance(p0);
-        body.push(Line::Fact(self.compile_target(p0)));
-
-        self.marker.advance_at_head(p1);
-        body.push(Line::Query(self.compile_target(p1)));
-        
-        Self::add_conditional_call(&mut body, p1);
-
-        body = clauses.iter()
-            .map(|ref term| self.compile_query(term))
-            .fold(body, |mut body, ref mut cqs| {
-                body.append(cqs);
-                body
-            });
-
-        body.push(Line::Control(ControlInstruction::Deallocate));
-        body
-    }
-
-    pub fn compile_fact(&mut self, term: &'a Term) -> Code {
-        self.marker.advance(term);
-
-        let mut compiled_fact = vec![Line::Fact(self.compile_target(term))];
-        let proceed = Line::Control(ControlInstruction::Proceed);
-
-        compiled_fact.push(proceed);
-        compiled_fact
-    }
-
-    pub fn compile_query(&mut self, term: &'a Term) -> Code {
-        self.marker.advance(term);
-
-        let mut compiled_query = vec![Line::Query(self.compile_target(term))];
-        Self::add_conditional_call(&mut compiled_query, term);
-
-        compiled_query
-    }
-
-    pub fn compile_predicate(&mut self, clauses: &'a Vec<PredicateClause>) -> Code
-    {
-        let mut code = Vec::new();
-        
-        for (i, clause) in clauses.iter().enumerate() {
-            self.marker.reset();
-            
-            let mut clause_code = match clause {
-                &PredicateClause::Fact(ref fact) =>
-                    self.compile_fact(fact),
-                &PredicateClause::Rule(ref rule) =>
-                    self.compile_rule(rule)
-            };
-
-            let choice = match i {
-                0 => ChoiceInstruction::TryMeElse(clause_code.len() + 1),
-                _ if i == clauses.len() - 1 => ChoiceInstruction::TrustMe,
-                _ => ChoiceInstruction::RetryMeElse(clause_code.len() + 1)
-            };
-
-            code.push(Line::Choice(choice));
-            code.append(&mut clause_code);
-        }
-
-        code
-    }
-}

src/l3/heapview.rs

@@ -1,86 +0,0 @@
-use l3::and_stack::*;
-use l3::ast::*;
-
-use std::vec::Vec;
-
-#[derive(Clone, Copy)]
-pub enum HeapCellView<'a> {
-    Str(usize, &'a Atom),
-    HeapVar(usize),
-    StackVar(usize, usize)
-}
-
-pub struct HeapCellViewer<'a> {
-    heap: &'a Heap,
-    and_stack: &'a AndStack,
-    state_stack: Vec<Addr>
-}
-
-impl<'a> HeapCellViewer<'a> {
-    pub fn new(heap: &'a Heap, and_stack: &'a AndStack, focus: Addr) -> Self {
-        HeapCellViewer {
-            heap: heap,
-            and_stack: and_stack,
-            state_stack: vec![focus]
-        }
-    }
-
-    fn follow_stack_ref(&mut self, mut fr: usize, mut sc: usize) -> HeapCellView<'a>
-    {
-        loop {
-            match self.and_stack[fr][sc] {
-                Addr::HeapCell(hc) | Addr::Str(hc) =>
-                    return self.follow_heap_ref(hc),
-                Addr::StackCell(fr1, sc1) => {
-                    if fr1 == fr && sc1 == sc {
-                        return HeapCellView::StackVar(fr, sc);
-                    }
-
-                    fr = fr1; sc = sc1;
-                }
-            }
-        }
-    }
-
-    fn follow_heap_ref(&mut self, mut focus: usize) -> HeapCellView<'a> {
-        loop {
-            match &self.heap[focus] {
-                &HeapCellValue::NamedStr(arity, ref name) => {
-                    for i in (1 .. arity + 1).rev() {
-                        self.state_stack.push(Addr::HeapCell(focus + i));
-                    }
-
-                    return HeapCellView::Str(arity, name);
-                },
-                &HeapCellValue::Ref(Ref::HeapCell(hc)) => {
-                    if focus == hc {
-                        return HeapCellView::HeapVar(hc);
-                    } else {
-                        focus = hc;
-                    }
-                },
-                &HeapCellValue::Ref(Ref::StackCell(fr, sc)) =>
-                    return self.follow_stack_ref(fr, sc),
-                &HeapCellValue::Str(cell_num) =>
-                    focus = cell_num,
-            }
-        }
-    }
-}
-
-impl<'a> Iterator for HeapCellViewer<'a> {
-    type Item = HeapCellView<'a>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if let Some(addr) = self.state_stack.pop() {
-            match addr {
-                Addr::HeapCell(hc) | Addr::Str(hc) =>
-                    return Some(self.follow_heap_ref(hc)),
-                Addr::StackCell(fr, sc) =>
-                    return Some(self.follow_stack_ref(fr, sc))
-            }
-        }
-
-        None
-    }
-}

src/l3/io.rs

@@ -1,255 +0,0 @@
-use l3::ast::*;
-use l3::codegen::*;
-use l3::l3_parser::*;
-use l3::machine::*;
-
-use termion::raw::IntoRawMode;
-use termion::input::TermRead;
-use termion::event::Key;
-
-use std::io::{Write, stdin, stdout};
-use std::fmt;
-
-impl fmt::Display for FactInstruction {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &FactInstruction::GetStructure(Level::Deep, ref name, ref arity, ref r) =>
-                write!(f, "get_structure {}/{}, {}", name, arity, r),
-            &FactInstruction::GetStructure(Level::Shallow, ref name, ref arity, ref r) =>
-                write!(f, "get_structure {}/{}, A{}", name, arity, r.reg_num()),
-            &FactInstruction::GetValue(ref x, ref a) =>
-                write!(f, "get_value {}, A{}", x, a),
-            &FactInstruction::GetVariable(ref x, ref a) =>
-                write!(f, "get_variable {}, A{}", x, a),
-            &FactInstruction::UnifyVariable(ref r) =>
-                write!(f, "unify_variable {}", r),
-            &FactInstruction::UnifyValue(ref r) =>
-                write!(f, "unify_value {}", r)
-        }
-    }
-}
-
-impl fmt::Display for QueryInstruction {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &QueryInstruction::PutStructure(Level::Deep, ref name, ref arity, ref r) =>
-                write!(f, "put_structure {}/{}, {}", name, arity, r.reg_num()),
-            &QueryInstruction::PutStructure(Level::Shallow, ref name, ref arity, ref r) =>
-                write!(f, "put_structure {}/{}, A{}", name, arity, r.reg_num()),
-            &QueryInstruction::PutValue(ref x, ref a) =>
-                write!(f, "put_value {}, A{}", x, a),
-            &QueryInstruction::PutVariable(ref x, ref a) =>
-                write!(f, "put_variable {}, A{}", x, a),
-            &QueryInstruction::SetVariable(ref r) =>
-                write!(f, "set_variable {}", r),
-            &QueryInstruction::SetValue(ref r) =>
-                write!(f, "set_value {}", r),
-        }
-    }
-}
-
-impl fmt::Display for ControlInstruction {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &ControlInstruction::Allocate(num_cells) =>
-                write!(f, "allocate {}", num_cells),
-            &ControlInstruction::Call(ref name, ref arity) =>
-                write!(f, "call {}/{}", name, arity),
-            &ControlInstruction::Deallocate =>
-                write!(f, "deallocate"),
-            &ControlInstruction::Proceed =>
-                write!(f, "proceed")
-        }
-    }
-}
-
-impl fmt::Display for ChoiceInstruction {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &ChoiceInstruction::TryMeElse(offset) =>
-                write!(f, "try_me_else {}", offset),
-            &ChoiceInstruction::RetryMeElse(offset) =>
-                write!(f, "retry_me_else {}", offset),
-            &ChoiceInstruction::TrustMe =>
-                write!(f, "trust_me")
-        }
-    }
-}
-
-impl fmt::Display for Level {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &Level::Shallow => write!(f, "A"),
-            &Level::Deep => write!(f, "X")
-        }
-    }
-}
-
-impl fmt::Display for VarReg {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &VarReg::Norm(RegType::Perm(reg)) => write!(f, "Y{}", reg),
-            &VarReg::Norm(RegType::Temp(reg)) => write!(f, "X{}", reg),
-            &VarReg::ArgAndNorm(RegType::Perm(reg), arg) =>
-                write!(f, "Y{} A{}", reg, arg),
-            &VarReg::ArgAndNorm(RegType::Temp(reg), arg) =>
-                write!(f, "X{} A{}", reg, arg)
-        }
-    }
-}
-
-impl fmt::Display for RegType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &RegType::Perm(val) => write!(f, "Y{}", val),
-            &RegType::Temp(val) => write!(f, "X{}", val)
-        }
-    }
-}
-
-
-fn is_consistent(predicate: &Vec<PredicateClause>) -> bool {
-    let name  = predicate.first().unwrap().name();
-    let arity = predicate.first().unwrap().arity();
-
-    for clause in predicate.iter().skip(1) {
-        if !(name == clause.name() && arity == clause.arity()) {
-            return false;
-        }
-    }
-
-    true
-}
-
-#[allow(dead_code)]
-pub fn print_code(code: &Code) {
-    for clause in code {
-        match clause {
-            &Line::Fact(ref fact) =>
-                for fact_instr in fact {
-                    println!("{}", fact_instr);
-                },
-            &Line::Choice(ref choice) =>
-                println!("{}", choice),
-            &Line::Control(ref control) =>
-                println!("{}", control),
-            &Line::Query(ref query) =>
-                for query_instr in query {
-                    println!("{}", query_instr);
-                }
-        }
-    }
-}
-
-pub fn read() -> String {
-    let _ = stdout().flush();
-
-    let mut buffer = String::new();
-    let mut result = String::new();
-
-    let stdin = stdin();
-    stdin.read_line(&mut buffer).unwrap();
-
-    if &*buffer.trim() == ":{" {
-        buffer.clear();
-
-        stdin.read_line(&mut buffer).unwrap();
-
-        while &*buffer.trim() != "}:" {
-            result += buffer.as_str();
-            buffer.clear();
-            stdin.read_line(&mut buffer).unwrap();
-        }
-    } else {
-        result = buffer;
-    }
-
-    result
-}
-
-pub fn eval(wam: &mut Machine, buffer: &str) -> EvalResult
-{
-    let result = parse_TopLevel(buffer);
-    let mut cg = CodeGenerator::new();
-
-    match &result {
-        &Ok(TopLevel::Predicate(ref clauses)) => {
-            if is_consistent(clauses) {
-                let compiled_pred = cg.compile_predicate(clauses);
-                wam.add_predicate(clauses, compiled_pred);
-
-                EvalResult::EntrySuccess
-            } else {
-                let msg = r"Error: predicate is inconsistent.
-Each predicate must have the same name and arity.";
-
-                println!("{}", msg);
-                EvalResult::EntryFailure
-            }
-        },
-        &Ok(TopLevel::Fact(ref fact)) => {
-            let compiled_fact = cg.compile_fact(&fact);
-            wam.add_fact(fact, compiled_fact);
-            EvalResult::EntrySuccess
-        },
-        &Ok(TopLevel::Rule(ref rule)) => {
-            let compiled_rule = cg.compile_rule(&rule);
-            wam.add_rule(rule, compiled_rule);
-            EvalResult::EntrySuccess
-        },
-        &Ok(TopLevel::Query(ref query)) => {
-            let compiled_query = cg.compile_query(&query);
-            wam.run_query(compiled_query, &cg)
-        },
-        &Err(_) => {
-            println!("Grammatical error of some kind!");
-            EvalResult::EntryFailure
-        }
-    }
-}
-
-pub fn print(wam: &mut Machine, result: EvalResult) {
-    match result {
-        EvalResult::InitialQuerySuccess(heap_locs) => {
-            println!("yes");
-
-            'outer: loop {
-                let mut result = EvalResult::QueryFailure;
-                let bindings = wam.heap_view(&heap_locs);
-
-                let stdin  = stdin();
-                let mut stdout = stdout().into_raw_mode().unwrap();
-
-                write!(stdout, "{}\n\r", bindings).unwrap();
-                stdout.flush().unwrap();
-
-                if !wam.or_stack_is_empty() {
-                    write!(stdout, "Press ; to continue or A to abort.\n\r").unwrap();
-                    stdout.flush().unwrap();
-
-                    for c in stdin.keys() {
-                        match c.unwrap() {
-                            Key::Char(';') => {
-                                result = wam.continue_query();
-                                break;
-                            },
-                            Key::Char('a') | Key::Char('A') =>
-                                break 'outer,
-                            _ => {}
-                        }
-                    };
-
-                    if let &EvalResult::QueryFailure = &result {
-                        write!(stdout, "no\n\r").unwrap();
-                        stdout.flush().unwrap();
-                        break;
-                    }
-                } else {
-                    break;
-                }
-            }
-        },
-        EvalResult::QueryFailure => println!("no"),
-        _ => {}
-    };
-}

src/l3/iterators.rs

@@ -1,175 +0,0 @@
-use l3::ast::*;
-
-use std::cell::Cell;
-use std::collections::VecDeque;
-use std::vec::Vec;
-
-enum IteratorState<'a> {
-    Atom(Level, &'a Cell<RegType>, &'a Atom),
-    Clause(Level, usize, &'a Cell<RegType>, &'a Atom, &'a Vec<Box<Term>>),
-    IsolatedAtom(&'a Cell<RegType>, &'a Atom),
-    IsolatedVar(&'a Cell<VarReg>, &'a Var),
-    RootClause(usize, &'a Vec<Box<Term>>),
-    Var(Level, &'a Cell<VarReg>, &'a Var)
-}
-
-impl<'a> IteratorState<'a> {
-    fn to_state(lvl: Level, term: &'a Term) -> IteratorState<'a>
-    {
-        match term {
-            &Term::Atom(ref cell, ref atom) =>
-                IteratorState::Atom(lvl, cell, atom),
-            &Term::Clause(ref cell, ref atom, ref child_terms) =>
-                IteratorState::Clause(lvl, 0, cell, atom, child_terms),
-            &Term::Var(ref cell, ref var) =>
-                IteratorState::Var(lvl, cell, var)
-        }
-    }
-}
-
-pub struct QueryIterator<'a> {
-    state_stack: Vec<IteratorState<'a>>
-}
-
-impl<'a> QueryIterator<'a> {
-    fn push_clause(&mut self,
-                   lvl: Level,
-                   child_num: usize,
-                   cell: &'a Cell<RegType>,
-                   name: &'a Atom,
-                   child_terms: &'a Vec<Box<Term>>)
-    {
-        self.state_stack.push(IteratorState::Clause(lvl,
-                                                    child_num,
-                                                    cell,
-                                                    name,
-                                                    child_terms));
-    }
-
-    fn push_root_clause(&mut self,
-                        child_num: usize,
-                        child_terms: &'a Vec<Box<Term>>)
-    {
-        self.state_stack.push(IteratorState::RootClause(child_num, child_terms));
-    }
-
-    fn push_subterm(&mut self, lvl: Level, term: &'a Term) {
-        self.state_stack.push(IteratorState::to_state(lvl, term));
-    }
-
-    fn new(term: &'a Term) -> QueryIterator<'a> {
-        let state = match term {
-            &Term::Atom(ref cell, ref atom) =>
-                IteratorState::IsolatedAtom(cell, atom),
-            &Term::Clause(_, _, ref terms) =>
-                IteratorState::RootClause(0, terms),
-            &Term::Var(ref cell, ref var) =>
-                IteratorState::IsolatedVar(cell, var)
-        };
-
-        QueryIterator { state_stack: vec![state] }
-    }
-}
-
-impl<'a> Iterator for QueryIterator<'a> {
-    type Item = TermRef<'a>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        while let Some(iter_state) = self.state_stack.pop() {
-            match iter_state {
-                IteratorState::Atom(lvl, cell, atom) =>
-                    return Some(TermRef::Atom(lvl, cell, atom)),
-                IteratorState::Clause(lvl, child_num, cell, atom, child_terms) => {
-                    if child_num == child_terms.len() {
-                        return Some(TermRef::Clause(lvl, cell, atom, child_terms));
-                    } else {
-                        self.push_clause(lvl, child_num + 1, cell, atom, child_terms);
-                        self.push_subterm(Level::Deep, child_terms[child_num].as_ref());
-                    }
-                },
-                IteratorState::IsolatedAtom(cell, atom) =>
-                    return Some(TermRef::Atom(Level::Shallow, cell, atom)),
-                IteratorState::IsolatedVar(cell, var) =>
-                    return Some(TermRef::Var(Level::Shallow, cell, var)),
-                IteratorState::RootClause(child_num, child_terms) => {
-                    if child_num == child_terms.len() {
-                        return None;
-                    } else {
-                        self.push_root_clause(child_num + 1, child_terms);
-                        self.push_subterm(Level::Shallow, child_terms[child_num].as_ref());
-                    }
-                },
-                IteratorState::Var(lvl, cell, var) =>
-                    return Some(TermRef::Var(lvl, cell, var))
-            };
-        }
-
-        None
-    }
-}
-
-pub struct FactIterator<'a> {
-    state_queue: VecDeque<IteratorState<'a>>,
-}
-
-impl<'a> FactIterator<'a> {
-    fn push_subterm(&mut self, lvl: Level, term: &'a Term) {
-        self.state_queue.push_back(IteratorState::to_state(lvl, term));
-    }
-
-    fn new(term: &'a Term) -> FactIterator<'a> {
-        let states = match term {
-            &Term::Atom(ref cell, ref atom) =>
-                vec![IteratorState::IsolatedAtom(cell, atom)],
-            &Term::Clause(_, _, ref terms) =>
-                vec![IteratorState::RootClause(0, terms)],
-            &Term::Var(ref cell, ref var) =>
-                vec![IteratorState::IsolatedVar(cell, var)]
-        };
-
-        FactIterator { state_queue:  VecDeque::from(states) }
-    }
-}
-
-impl<'a> Iterator for FactIterator<'a> {
-    type Item = TermRef<'a>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        while let Some(state) = self.state_queue.pop_front() {
-            match state {
-                IteratorState::Atom(lvl, cell, atom) =>
-                    return Some(TermRef::Atom(lvl, cell, atom)),
-                IteratorState::Clause(lvl, _, cell, atom, child_terms) => {
-                    for child_term in child_terms {
-                        self.push_subterm(Level::Deep, child_term);
-                    }
-
-                    return Some(TermRef::Clause(lvl, cell, atom, child_terms));
-                },
-                IteratorState::IsolatedAtom(cell, atom) =>
-                    return Some(TermRef::Atom(Level::Shallow, cell, atom)),
-                IteratorState::IsolatedVar(cell, var) =>
-                    return Some(TermRef::Var(Level::Shallow, cell, var)),
-                IteratorState::RootClause(_, child_terms) => {
-                    for child_term in child_terms {
-                        self.push_subterm(Level::Shallow, child_term);
-                    }
-                },
-                IteratorState::Var(lvl, cell, var) =>
-                    return Some(TermRef::Var(lvl, cell, var))
-            }
-        }
-
-        None
-    }
-}
-
-impl Term {
-    pub fn post_order_iter(&self) -> QueryIterator {
-        QueryIterator::new(self)
-    }
-
-    pub fn breadth_first_iter(&self) -> FactIterator {
-        FactIterator::new(self)
-    }
-}

src/l3/l3_parser.lalrpop

@@ -1,59 +0,0 @@
-use l3::ast::*;
-
-use std::cell::Cell;
-
-grammar;
-
-pub TopLevel: TopLevel = {
-    "?-" <t:Term> "." => TopLevel::Query(t),
-    <Predicate> => TopLevel::Predicate(<>),
-    <Rule>  "." => TopLevel::Rule(<>),
-    <Term>  "." => TopLevel::Fact(<>)    
-};
-
-Atom : Atom = {
-    r"[a-z][a-z0-9_]*" => <>.trim().to_string(),
-};
-
-BoxedTerm : Box<Term> = {
-    <t:Term> => Box::new(t)
-};
-
-Clause : Term = {
-    <a:Atom> "(" <ts: (<BoxedTerm> ",")*> <t:BoxedTerm> ")" => {
-     	let mut ts = ts;
-     	ts.push(t);
-	Term::Clause(Cell::new(RegType::Temp(0)), a, ts)
-    }
-};
-
-Predicate : Vec<PredicateClause> = {
-    <pcs: (<PredicateClause>)+> <pc: PredicateClause> => {
-        let mut pcs = pcs;
-	pcs.push(pc);
-	pcs
-    }  
-};
-
-PredicateClause : PredicateClause = {
-    <Rule> "." => PredicateClause::Rule(<>),
-    <Term> "." => PredicateClause::Fact(<>)
-};
-
-Rule : Rule = {
-    <c:Clause> ":-" <h:Term> <cs: ("," <Term>)*> =>
-         Rule { head: (c, h), clauses: cs },
-    <a:Atom> ":-" <h:Term> <cs: ("," <Term>)*> =>
-         Rule { head: (Term::Atom(Cell::new(RegType::Temp(0)), a), h),
-	        clauses: cs }
-};
-
-Term : Term = {
-    <Clause> => <>,
-    <Atom>   => Term::Atom(Cell::new(RegType::Temp(0)), <>),
-    <Var>    => Term::Var(Cell::new(VarReg::Norm(RegType::Temp(0))), <>)
-};
-
-Var : Var = {
-    r"[A-Z][a-z0-9_]*" => <>.trim().to_string(),
-};

src/l3/machine.rs

@@ -1,677 +0,0 @@
-use l3::ast::*;
-use l3::codegen::*;
-use l3::heapview::*;
-use l3::and_stack::*;
-use l3::or_stack::*;
-
-use std::collections::HashMap;
-use std::ops::{Index, IndexMut};
-use std::vec::Vec;
-
-#[derive(Clone, Copy)]
-enum MachineMode {
-    Read,
-    Write
-}
-
-struct MachineState {
-    h: usize,
-    s: usize,
-    p: CodePtr,
-    b: usize,
-    e: usize,
-    num_of_args: usize,
-    cp: CodePtr,
-    fail: bool,
-    heap: Heap,
-    mode: MachineMode,
-    and_stack: AndStack,
-    or_stack: OrStack,
-    registers: Registers,
-    trail: Vec<Ref>,
-    tr: usize,
-    hb: usize
-}
-
-type CodeDir = HashMap<(Atom, usize), usize>;
-
-impl Index<RegType> for MachineState {
-    type Output = Addr;
-
-    fn index(&self, reg: RegType) -> &Self::Output {
-        match reg {
-            RegType::Temp(temp) => &self.registers[temp],
-            RegType::Perm(perm) => {
-                let e = self.e;
-                &self.and_stack[e][perm]
-            }
-        }
-    }
-}
-
-impl IndexMut<RegType> for MachineState {
-    fn index_mut(&mut self, reg: RegType) -> &mut Self::Output {
-        match reg {
-            RegType::Temp(temp) => &mut self.registers[temp],
-            RegType::Perm(perm) => {
-                let e = self.e;
-                &mut self.and_stack[e][perm]
-            }
-        }
-    }
-}
-
-pub struct Machine {
-    ms: MachineState,
-    code: Code,
-    code_dir: CodeDir
-}
-
-impl Machine {
-    pub fn new() -> Self {
-        Machine {
-            ms: MachineState::new(),
-            code: Vec::new(),
-            code_dir: HashMap::new()
-        }
-    }
-
-    pub fn failed(&self) -> bool {
-        self.ms.fail
-    }
-
-    pub fn add_fact(&mut self, fact: &Term, mut code: Code) {
-        let p = self.code.len();
-        let name  = fact.name().clone();
-        let arity = fact.arity();
-
-        self.code.append(&mut code);
-        self.code_dir.insert((name, arity), p);
-    }
-
-    pub fn add_rule(&mut self, rule: &Rule, mut code: Code) {
-        let p = self.code.len();
-        let name  = rule.head.0.name().clone();
-        let arity = rule.head.0.arity();
-
-        self.code.append(&mut code);
-        self.code_dir.insert((name, arity), p);
-    }
-
-    pub fn add_predicate(&mut self, pred: &Vec<PredicateClause>, mut code: Code)
-    {
-        let p = self.code.len();
-        let name  = pred.first().unwrap().name().clone();
-        let arity = pred.first().unwrap().arity();
-
-        self.code.append(&mut code);
-        self.code_dir.insert((name, arity), p);
-    }
-
-    fn execute_instr<'a>(&mut self, instr_src: LineOrCodeOffset<'a>) -> bool
-    {
-        let mut instr = match instr_src {
-            LineOrCodeOffset::Instruction(instr) => instr,
-            LineOrCodeOffset::Offset(p) => &self.code[p]
-        };
-
-        loop {
-            match instr {
-                &Line::Choice(ref choice_instr) =>
-                    self.ms.execute_choice_instr(choice_instr),
-                &Line::Fact(ref fact) => {
-                    for fact_instr in fact {
-                        self.ms.execute_fact_instr(&fact_instr);
-                    }
-                    self.ms.p += 1;
-                },
-                &Line::Query(ref query) => {
-                    for query_instr in query {
-                        self.ms.execute_query_instr(&query_instr);
-                    }
-                    self.ms.p += 1;
-                },
-                &Line::Control(ref control_instr) =>
-                    self.ms.execute_ctrl_instr(&self.code_dir, control_instr),
-            }
-
-            if self.failed() {
-                let p = self.ms
-                            .or_stack
-                            .top()
-                            .map(|fr| fr.bp)
-                            .unwrap_or_default();
-
-                if let CodePtr::TopLevel = p {
-                    return false;
-                } else {
-                    self.ms.fail = false;
-                    self.ms.p = p;
-                }
-            }
-
-            match self.ms.p {
-                CodePtr::DirEntry(p) if p < self.code.len() =>
-                    instr = &self.code[p],
-                _ => break
-            }
-        }
-
-        true
-    }
-
-    pub fn heap_view(&self, var_dir: &HeapVarDict) -> String {
-        let mut result = String::new();
-
-        for (var, addr) in var_dir {
-            let mut arities = Vec::new();
-            let viewer = HeapCellViewer::new(&self.ms.heap,
-                                             &self.ms.and_stack,
-                                             *addr);
-
-            if result != "" {
-                result += "\n\r";
-            }
-
-            result += var.as_str();
-            result += " = ";
-
-            for view in viewer {
-                match arities.pop() {
-                    Some(n) => arities.push(n-1),
-                    None => {}
-                }
-
-                if !(arities.is_empty() || result.ends_with("(")) {
-                    result += ", ";
-                }
-
-                match view {
-                    HeapCellView::Str(arity, ref name) => {
-                        result += name.as_str();
-
-                        if arity > 0 {
-                            arities.push(arity);
-                            result += "(";
-                        }
-                    },
-                    HeapCellView::HeapVar(cell_num) => {
-                        result += "_";
-                        result += cell_num.to_string().as_str();
-                    },
-                    HeapCellView::StackVar(fr, sc) => {
-                        result += "_s_";
-                        result += fr.to_string().as_str();
-                        result += "_";
-                        result += sc.to_string().as_str();
-                    }
-                }
-
-                while let Some(&0) = arities.last() {
-                    result += ")";
-                    arities.pop();
-                }
-            }
-        }
-
-        result
-    }
-
-    pub fn run_query(&mut self, code: Code, cg: &CodeGenerator) -> EvalResult
-    {
-        let mut succeeded = true;
-        let mut heap_locs = HashMap::new();
-
-        for instr in code.iter().take(1) {
-            succeeded = self.execute_instr(LineOrCodeOffset::from(instr));
-        }
-
-        if succeeded {
-            for (var, vr) in cg.vars() {
-                let addr = self.ms.registers[vr.root_register()];
-                heap_locs.insert((*var).clone(), addr);
-            }
-
-            for instr in code.iter().skip(1) {
-                succeeded = self.execute_instr(LineOrCodeOffset::from(instr));
-                if !succeeded {
-                    break;
-                }
-            }
-        }
-
-        if succeeded {
-            EvalResult::InitialQuerySuccess(heap_locs)
-        } else {
-            EvalResult::QueryFailure
-        }
-    }
-
-    pub fn or_stack_is_empty(&self) -> bool {
-        self.ms.or_stack.is_empty()
-    }
-
-    pub fn continue_query(&mut self) -> EvalResult
-    {
-        if !self.or_stack_is_empty() {
-            let b = self.ms.b;
-            self.ms.p = self.ms.or_stack[b].bp;
-
-            let succeeded = if let CodePtr::DirEntry(p) = self.ms.p {
-                self.execute_instr(LineOrCodeOffset::Offset(p))
-            } else {
-                false
-            };
-
-            if succeeded {
-                EvalResult::SubsequentQuerySuccess
-            } else {
-                EvalResult::QueryFailure
-            }
-        } else {
-            EvalResult::QueryFailure
-        }
-    }
-
-    pub fn reset(&mut self) {
-        self.ms.reset();
-    }
-}
-
-impl MachineState {
-    fn new() -> MachineState {
-        MachineState { h: 0,
-                       s: 0,
-                       p: CodePtr::TopLevel,
-                       b: 0,
-                       e: 0,
-                       num_of_args: 0,
-                       cp: CodePtr::TopLevel,
-                       fail: false,
-                       heap: Vec::with_capacity(256),
-                       mode: MachineMode::Write,
-                       and_stack: AndStack::new(),
-                       or_stack: OrStack::new(),
-                       registers: vec![Addr::HeapCell(0); 32],
-                       trail: Vec::new(),
-                       tr: 0,
-                       hb: 0
-        }
-    }
-
-    fn num_frames(&self) -> usize {
-        self.and_stack.len() + self.or_stack.len()
-    }
-
-    fn store(&self, a: Addr) -> Addr {
-        match a {
-            Addr::HeapCell(r)       => self.heap[r].as_addr(r),
-            Addr::StackCell(fr, sc) => self.and_stack[fr][sc],
-            addr                    => addr
-        }
-    }
-
-    fn deref(&self, a: Addr) -> Addr {
-        let mut a = a;
-
-        loop {
-            let value = self.store(a);
-
-            if value.is_ref() && value != a {
-                a = value;
-                continue;
-            }
-
-            return a;
-        };
-    }
-
-    fn bind(&mut self, r1: Ref, a2: Addr) {
-        let t2 = self.store(a2);
-
-        match r1 {
-            Ref::StackCell(fr, sc) =>
-                self.and_stack[fr][sc] = t2,
-            Ref::HeapCell(hc) =>
-                self.heap[hc] = HeapCellValue::from(t2)
-        };
-
-        self.trail(r1);
-    }
-
-    fn unify(&mut self, a1: Addr, a2: Addr) {
-        let mut pdl = vec![a1, a2];
-
-        self.fail = false;
-
-        while !(pdl.is_empty() || self.fail) {
-            let d1 = self.deref(pdl.pop().unwrap());
-            let d2 = self.deref(pdl.pop().unwrap());
-
-            if d1 != d2 {
-                match (self.store(d1), self.store(d2)) {
-                    (Addr::HeapCell(hc), _) =>
-                        self.bind(Ref::HeapCell(hc), d2),
-                    (_, Addr::HeapCell(hc)) =>
-                        self.bind(Ref::HeapCell(hc), d1),
-                    (Addr::StackCell(fr, sc), _) =>
-                        self.bind(Ref::StackCell(fr, sc), d2),
-                    (_, Addr::StackCell(fr, sc)) =>
-                        self.bind(Ref::StackCell(fr, sc), d1),
-                    (Addr::Str(a1), Addr::Str(a2)) => {
-                        let r1 = &self.heap[a1];
-                        let r2 = &self.heap[a2];
-
-                        if let &HeapCellValue::NamedStr(n1, ref f1) = r1 {
-                            if let &HeapCellValue::NamedStr(n2, ref f2) = r2 {
-                                if n1 == n2 && *f1 == *f2 {
-                                    for i in 1 .. n1 + 1 {
-                                        pdl.push(Addr::HeapCell(a1 + i));
-                                        pdl.push(Addr::HeapCell(a2 + i));
-                                    }
-
-                                    continue;
-                                }
-                            }
-                        }
-
-                        self.fail = true;
-                    }
-                };
-            }
-        }
-    }
-
-    fn trail(&mut self, r: Ref) {
-        match r {
-            Ref::HeapCell(hc) => {
-                if hc < self.hb {
-                    self.trail.push(r);
-                    self.tr += 1;
-                }
-            },
-            Ref::StackCell(fr, _) => {
-                let fr_gi = self.and_stack[fr].global_index;
-                let b_gi  = if !self.or_stack.is_empty() {
-                    self.or_stack[self.b].global_index
-                } else {
-                    0
-                };
-
-                if fr_gi < b_gi {
-                    self.trail.push(r);
-                    self.tr += 1;
-                }
-            }
-        }
-    }
-
-    fn unwind_trail(&mut self, a1: usize, a2: usize) {
-        for i in a1 .. a2 {
-            match self.trail[i] {
-                Ref::HeapCell(r) =>
-                    self.heap[r] = HeapCellValue::Ref(self.trail[i]),
-                Ref::StackCell(fr, sc) =>
-                    self.and_stack[fr][sc] = Addr::StackCell(fr, sc)
-            }
-        }
-    }
-
-    fn execute_query_instr(&mut self, instr: &QueryInstruction) {
-        match instr {
-            &QueryInstruction::PutStructure(_, ref name, arity, reg) => {
-                self.heap.push(HeapCellValue::Str(self.h + 1));
-                self.heap.push(HeapCellValue::NamedStr(arity, name.clone()));
-
-                self[reg] = Addr::Str(self.h + 1);
-
-                self.h += 2;
-            },
-            &QueryInstruction::PutValue(norm, arg) =>
-                self.registers[arg] = self[norm],
-            &QueryInstruction::PutVariable(norm, arg) => {
-                self.heap.push(HeapCellValue::Ref(Ref::HeapCell(self.h)));
-
-                self[norm] = Addr::HeapCell(self.h);
-                self.registers[arg] = Addr::HeapCell(self.h);
-
-                self.h += 1;
-            },
-            &QueryInstruction::SetVariable(reg) => {
-                self.heap.push(HeapCellValue::Ref(Ref::HeapCell(self.h)));
-                self[reg] = Addr::HeapCell(self.h);
-
-                self.h += 1;
-            },
-            &QueryInstruction::SetValue(reg) => {
-                let heap_val = self[reg];
-                self.heap.push(HeapCellValue::from(heap_val));
-
-                self.h += 1;
-            },
-        }
-    }
-
-    fn execute_fact_instr(&mut self, instr: &FactInstruction) {
-        match instr {
-            &FactInstruction::GetStructure(_, ref name, arity, reg) => {
-                let addr = self.deref(self[reg]);
-
-                match self.store(addr) {
-                    Addr::Str(a) => {
-                        let result = &self.heap[a];
-
-                        if let &HeapCellValue::NamedStr(narity, ref str) = result {
-                            if narity == arity && *name == *str {
-                                self.s = a + 1;
-                                self.mode = MachineMode::Read;
-                            } else {
-                                self.fail = true;
-                            }
-                        }
-                    },
-                    Addr::HeapCell(_) | Addr::StackCell(_, _) => {
-                        self.heap.push(HeapCellValue::Str(self.h + 1));
-                        self.heap.push(HeapCellValue::NamedStr(arity, name.clone()));
-
-                        let h = self.h;
-
-                        self.bind(addr.as_ref().unwrap(), Addr::HeapCell(h));
-
-                        self.h += 2;
-                        self.mode = MachineMode::Write;
-                    }
-                };
-            },
-            &FactInstruction::GetVariable(norm, arg) =>
-                self[norm] = self.registers[arg],
-            &FactInstruction::GetValue(norm, arg) => {
-                let norm_addr = self[norm];
-                let reg_addr  = self.registers[arg];
-
-                self.unify(norm_addr, reg_addr);
-            },
-            &FactInstruction::UnifyVariable(reg) => {
-                match self.mode {
-                    MachineMode::Read  =>
-                        self[reg] = self.heap[self.s].as_addr(self.s),
-                    MachineMode::Write => {
-                        self.heap.push(HeapCellValue::Ref(Ref::HeapCell(self.h)));
-                        self[reg] = Addr::HeapCell(self.h);
-                        self.h += 1;
-                    }
-                };
-
-                self.s += 1;
-            },
-            &FactInstruction::UnifyValue(reg) => {
-                let s = self.s;
-
-                match self.mode {
-                    MachineMode::Read  => {
-                        let reg_addr = self[reg];
-                        self.unify(reg_addr, Addr::HeapCell(s));
-                    },
-                    MachineMode::Write => {
-                        let heap_val = self.store(self[reg]);
-                        self.heap.push(HeapCellValue::from(heap_val));
-                        self.h += 1;
-                    }
-                };
-
-                self.s += 1;
-            }
-        };
-    }
-
-    fn execute_ctrl_instr(&mut self, code_dir: &CodeDir, instr: &ControlInstruction)
-    {
-        match instr {
-            &ControlInstruction::Allocate(num_cells) => {
-                let num_frames = self.num_frames();
-
-                self.and_stack.push(num_frames + 1, self.e, self.cp, num_cells);
-
-                self.e = self.and_stack.len() - 1;
-                self.p += 1;
-            },
-            &ControlInstruction::Call(ref name, arity) => {
-                let compiled_tl_index = code_dir.get(&(name.clone(), arity))
-                                                .map(|index| *index);
-
-                match compiled_tl_index {
-                    Some(compiled_tl_index) => {
-                        self.cp = self.p + 1;
-                        self.num_of_args = arity;
-                        self.p  = CodePtr::DirEntry(compiled_tl_index);
-                    },
-                    None => self.fail = true
-                };
-            },
-            &ControlInstruction::Deallocate => {
-                let e = self.e;
-
-                let num_frame_e = self.and_stack.top().unwrap().global_index;
-                let num_frame_b = self.or_stack
-                                      .top()
-                                      .map(|fr| fr.global_index)
-                                      .unwrap_or(0);
-
-                self.p = self.and_stack[e].cp;
-                self.e = self.and_stack[e].e;
-
-                if num_frame_e > num_frame_b {
-                    let top_e = self.and_stack.top().unwrap().e;
-                    self.and_stack.drop_frames(top_e - self.e + 1);
-                }
-            },
-            &ControlInstruction::Proceed =>
-                self.p = self.cp,
-        };
-    }
-
-    fn execute_choice_instr(&mut self, instr: &ChoiceInstruction)
-    {
-        match instr {
-            &ChoiceInstruction::TryMeElse(offset) => {
-                let n = self.num_of_args;
-                let num_frames = self.num_frames();
-
-                self.or_stack.push(num_frames + 1,
-                                   self.e,
-                                   self.cp,
-                                   self.b,
-                                   self.p + offset,
-                                   self.tr,
-                                   self.h,
-                                   self.num_of_args);
-
-                self.b = self.or_stack.len() - 1;
-                let b = self.b;
-
-                for i in 1 .. n + 1 {
-                    self.or_stack[b][i] = self.registers[i];
-                }
-
-                self.hb = self.h;
-                self.p += 1;
-            },
-            &ChoiceInstruction::RetryMeElse(offset) => {
-                let b = self.b;
-                let n = self.or_stack[b].num_args();
-
-                for i in 1 .. n + 1 {
-                    self.registers[i] = self.or_stack[b][i];
-                }
-
-                self.e = self.or_stack[b].e;
-                self.cp = self.or_stack[b].cp;
-
-                self.or_stack[b].bp = self.p + offset;
-
-                let old_tr  = self.or_stack[b].tr;
-                let curr_tr = self.tr;
-
-                self.unwind_trail(old_tr, curr_tr);
-                self.tr = self.or_stack[b].tr;
-
-                self.trail.truncate(self.tr);
-                self.heap.truncate(self.or_stack[b].h);
-
-                self.h  = self.or_stack[b].h;
-                self.hb = self.h;
-
-                self.p += 1;
-            },
-            &ChoiceInstruction::TrustMe => {
-                let b = self.b;
-                let n = self.or_stack[b].num_args();
-
-                for i in 1 .. n + 1 {
-                    self.registers[i] = self.or_stack[b][i];
-                }
-
-                self.e  = self.or_stack[b].e;
-                self.cp = self.or_stack[b].cp;
-
-                let old_tr  = self.or_stack[b].tr;
-                let curr_tr = self.tr;
-
-                self.unwind_trail(old_tr, curr_tr);
-
-                self.tr = self.or_stack[b].tr;
-                self.trail.truncate(self.tr);
-
-                self.h = self.or_stack[b].h;
-                self.heap.truncate(self.h);
-
-                self.b = self.or_stack[b].b;
-
-                self.or_stack.pop();
-
-                self.hb = self.h;
-                self.p += 1;
-            }
-        }
-    }
-
-    fn reset(&mut self) {
-        self.h = 0;
-        self.hb = 0;
-        self.e = 0;
-        self.b = 0;
-        self.s = 0;
-        self.tr = 0;
-        self.p = CodePtr::TopLevel;
-        self.cp = CodePtr::TopLevel;
-        self.num_of_args = 0;
-
-        self.fail = false;
-        self.trail.clear();
-        self.heap.clear();
-        self.mode = MachineMode::Write;
-        self.and_stack.clear();
-        self.or_stack.clear();
-        self.registers = vec![Addr::HeapCell(0); 32];
-    }
-}

src/l3/mod.rs

@@ -1,9 +0,0 @@
-pub mod and_stack;
-pub mod ast;
-pub mod codegen;
-pub mod heapview;
-pub mod io;
-pub mod iterators;
-pub mod l3_parser;
-pub mod machine;
-pub mod or_stack;

src/l3/or_stack.rs

@@ -1,112 +0,0 @@
-use l3::ast::*;
-
-use std::ops::{Index, IndexMut};
-use std::vec::Vec;
-
-pub struct Frame {
-    pub global_index: usize,
-    pub e: usize,
-    pub cp: CodePtr,
-    pub b: usize,
-    pub bp: CodePtr,
-    pub tr: usize,
-    pub h: usize,
-    args: Vec<Addr>
-}
-
-impl Frame {
-    fn new(global_index: usize,
-           e: usize,
-           cp: CodePtr,
-           b: usize,
-           bp: CodePtr,
-           tr: usize,
-           h: usize,
-           n: usize)
-           -> Self
-    {
-        Frame {
-            global_index: global_index,
-            e: e,
-            cp: cp,
-            b: b,
-            bp: bp,
-            tr: tr,
-            h: h,
-            args: vec![Addr::HeapCell(0); n]
-        }
-    }
-
-    pub fn num_args(&self) -> usize {
-        self.args.len()
-    }
-}
-
-pub struct OrStack(Vec<Frame>);
-
-impl OrStack {
-    pub fn new() -> Self {
-        OrStack(Vec::new())
-    }
-
-    pub fn push(&mut self,
-                global_index: usize,
-                e: usize,
-                cp: CodePtr,
-                b: usize,
-                bp: CodePtr,
-                tr: usize,
-                h: usize,
-                n: usize)
-    {
-        self.0.push(Frame::new(global_index, e, cp, b, bp, tr, h, n));
-    }
-
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    pub fn clear(&mut self) {
-        self.0.clear()
-    }
-
-    pub fn top(&self) -> Option<&Frame> {
-        self.0.last()
-    }
-
-    pub fn pop(&mut self) {
-        self.0.pop();
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-}
-
-impl Index<usize> for OrStack {
-    type Output = Frame;
-
-    fn index(&self, index: usize) -> &Self::Output {
-        self.0.index(index)
-    }
-}
-
-impl IndexMut<usize> for OrStack {
-    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
-        self.0.index_mut(index)
-    }
-}
-
-impl Index<usize> for Frame {
-    type Output = Addr;
-
-    fn index(&self, index: usize) -> &Self::Output {
-        self.args.index(index - 1)
-    }
-}
-
-impl IndexMut<usize> for Frame {
-    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
-        self.args.index_mut(index - 1)
-    }
-}

src/main.rs

@@ -1,5 +1,7 @@
+extern crate crossterm;
 #[macro_use]
 extern crate downcast;
+extern crate git_version;
 extern crate indexmap;
 #[macro_use]
 extern crate lazy_static;
@@ -9,20 +11,19 @@ extern crate nix;
 extern crate prolog_parser;
 #[macro_use]
 extern crate ref_thread_local;
-extern crate termion;
 
+use git_version::git_version;
 use nix::sys::signal;
 
 mod prolog;
 
 use crate::prolog::machine::*;
+use crate::prolog::machine::streams::*;
 use crate::prolog::read::*;
 
+use std::env;
 use std::sync::atomic::Ordering;
 
-#[cfg(test)]
-mod tests;
-
 extern fn handle_sigint(signal: libc::c_int) {
     let signal = signal::Signal::from_c_int(signal).unwrap();
     if signal == signal::Signal::SIGINT {
@@ -34,6 +35,11 @@ fn main() {
     let handler = signal::SigHandler::Handler(handle_sigint);
     unsafe { signal::signal(signal::Signal::SIGINT, handler) }.unwrap();
 
-    let mut wam = Machine::new(readline::input_stream());
+    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();
 }

src/prolog/arithmetic.rs

@@ -6,6 +6,7 @@ use crate::prolog::forms::*;
 use crate::prolog::instructions::*;
 use crate::prolog::iterators::*;
 
+use crate::prolog::machine::heap::*;
 use crate::prolog::machine::machine_errors::*;
 use crate::prolog::machine::machine_indices::*;
 
@@ -15,6 +16,7 @@ use crate::prolog::rug::{Assign, Integer, Rational};
 
 use std::cell::Cell;
 use std::cmp::{max, min, Ordering};
+use std::convert::TryFrom;
 use std::f64;
 use std::num::FpCategory;
 use std::ops::{Add, Div, Mul, Neg, Sub};
@@ -159,6 +161,7 @@ impl<'a> ArithmeticEvaluator<'a> {
             "round" => Ok(ArithmeticInstruction::Round(a1, t)),
             "ceiling" => Ok(ArithmeticInstruction::Ceiling(a1, t)),
             "floor" => Ok(ArithmeticInstruction::Floor(a1, t)),
+            "sign" => Ok(ArithmeticInstruction::Sign(a1, t)),
             "\\" => Ok(ArithmeticInstruction::BitwiseComplement(a1, t)),
             _ => Err(ArithmeticError::NonEvaluableFunctor(
                 Constant::Atom(name, None),
@@ -192,6 +195,7 @@ impl<'a> ArithmeticEvaluator<'a> {
             "xor" => Ok(ArithmeticInstruction::Xor(a1, a2, t)),
             "mod" => Ok(ArithmeticInstruction::Mod(a1, a2, t)),
             "rem" => Ok(ArithmeticInstruction::Rem(a1, a2, t)),
+            "gcd" => Ok(ArithmeticInstruction::Gcd(a1, a2, t)),
             "atan2" => Ok(ArithmeticInstruction::ATan2(a1, a2, t)),
             _ => Err(ArithmeticError::NonEvaluableFunctor(
                 Constant::Atom(name, None),
@@ -260,6 +264,9 @@ impl<'a> ArithmeticEvaluator<'a> {
 
     fn push_constant(&mut self, c: &Constant) -> Result<(), ArithmeticError> {
         match c {
+            &Constant::Fixnum(n) => self
+                .interm
+                .push(ArithmeticTerm::Number(Number::Fixnum(n))),
             &Constant::Integer(ref n) => self
                 .interm
                 .push(ArithmeticTerm::Number(Number::Integer(n.clone()))),
@@ -314,18 +321,25 @@ impl<'a> ArithmeticEvaluator<'a> {
 }
 
 // integer division rounding function -- 9.1.3.1.
-pub fn rnd_i<'a>(n: &'a Number) -> RefOrOwned<'a, Integer> {
+pub fn rnd_i<'a>(n: &'a Number) -> RefOrOwned<'a, Number> {
     match n {
-        &Number::Integer(ref n) => RefOrOwned::Borrowed(n),
+        &Number::Integer(_) => {
+            RefOrOwned::Borrowed(n)
+        }
         &Number::Float(OrderedFloat(f)) => {
-            RefOrOwned::Owned(Integer::from_f64(f.floor()).unwrap_or_else(|| Integer::from(0)))
+            RefOrOwned::Owned(Number::from(
+                Integer::from_f64(f.floor()).unwrap_or_else(|| Integer::from(0))
+            ))
+        }
+        &Number::Fixnum(n) => {
+            RefOrOwned::Owned(Number::from(n))
         }
         &Number::Rational(ref r) => {
             let r_ref = r.fract_floor_ref();
             let (mut fract, mut floor) = (Rational::new(), Integer::new());
-
             (&mut fract, &mut floor).assign(r_ref);
-            RefOrOwned::Owned(floor)
+
+            RefOrOwned::Owned(Number::from(floor))
         }
     }
 }
@@ -333,6 +347,7 @@ pub fn rnd_i<'a>(n: &'a Number) -> RefOrOwned<'a, Integer> {
 // floating point rounding function -- 9.1.4.1.
 pub fn rnd_f(n: &Number) -> f64 {
     match n {
+        &Number::Fixnum(n) => n as f64,
         &Number::Integer(ref n) => n.to_f64(),
         &Number::Float(OrderedFloat(f)) => f,
         &Number::Rational(ref r) => r.to_f64(),
@@ -368,22 +383,32 @@ where
     }
 }
 
+#[inline]
+fn float_fn_to_f(n: isize) -> Result<f64, EvalError> {
+    classify_float(n as f64, rnd_f)
+}
+
+#[inline]
 fn float_i_to_f(n: &Integer) -> Result<f64, EvalError> {
     classify_float(n.to_f64(), rnd_f)
 }
 
+#[inline]
 fn float_r_to_f(r: &Rational) -> Result<f64, EvalError> {
     classify_float(r.to_f64(), rnd_f)
 }
 
+#[inline]
 fn add_f(f1: f64, f2: f64) -> Result<OrderedFloat<f64>, EvalError> {
     Ok(OrderedFloat(classify_float(f1 + f2, rnd_f)?))
 }
 
+#[inline]
 fn mul_f(f1: f64, f2: f64) -> Result<OrderedFloat<f64>, EvalError> {
     Ok(OrderedFloat(classify_float(f1 * f2, rnd_f)?))
 }
 
+#[inline]
 fn div_f(f1: f64, f2: f64) -> Result<OrderedFloat<f64>, EvalError> {
     if FpCategory::Zero == f2.classify() {
         Err(EvalError::ZeroDivisor)
@@ -397,23 +422,46 @@ impl Add<Number> for Number {
 
     fn add(self, rhs: Number) -> Self::Output {
         match (self, rhs) {
-            (Number::Integer(n1), Number::Integer(n2)) => Ok(Number::Integer(n1 + n2)), // add_i
+            (Number::Fixnum(n1), Number::Fixnum(n2)) => {
+                Ok(if let Some(result) = n1.checked_add(n2) {
+                    Number::Fixnum(result)
+                } else {
+                    Number::from(Integer::from(n1) + Integer::from(n2))
+                })
+            }
+            (Number::Fixnum(n1), Number::Integer(n2)) |
+            (Number::Integer(n2), Number::Fixnum(n1)) => {
+                Ok(Number::from(Integer::from(n1) + &*n2))
+            }
+            (Number::Fixnum(n1), Number::Rational(n2)) |
+            (Number::Rational(n2), Number::Fixnum(n1)) => {
+                Ok(Number::from(Rational::from(n1) + &*n2))
+            }
+            (Number::Fixnum(n1), Number::Float(OrderedFloat(n2))) |
+            (Number::Float(OrderedFloat(n2)), Number::Fixnum(n1)) => {
+                Ok(Number::Float(add_f(float_fn_to_f(n1)?, n2)?))
+            }
+            (Number::Integer(n1), Number::Integer(n2)) => {
+                Ok(Number::from(Integer::from(&*n1) + &*n2)) // add_i
+            }
             (Number::Integer(n1), Number::Float(OrderedFloat(n2)))
-            | (Number::Float(OrderedFloat(n2)), Number::Integer(n1)) => {
+          | (Number::Float(OrderedFloat(n2)), Number::Integer(n1)) => {
                 Ok(Number::Float(add_f(float_i_to_f(&n1)?, n2)?))
             }
             (Number::Integer(n1), Number::Rational(n2))
-            | (Number::Rational(n2), Number::Integer(n1)) => {
-                Ok(Number::Rational(Rational::from(n1) + n2))
+          | (Number::Rational(n2), Number::Integer(n1)) => {
+                Ok(Number::from(Rational::from(&*n1) + &*n2))
             }
             (Number::Rational(n1), Number::Float(OrderedFloat(n2)))
-            | (Number::Float(OrderedFloat(n2)), Number::Rational(n1)) => {
+          | (Number::Float(OrderedFloat(n2)), Number::Rational(n1)) => {
                 Ok(Number::Float(add_f(float_r_to_f(&n1)?, n2)?))
             }
             (Number::Float(OrderedFloat(f1)), Number::Float(OrderedFloat(f2))) => {
                 Ok(Number::Float(add_f(f1, f2)?))
             }
-            (Number::Rational(r1), Number::Rational(r2)) => Ok(Number::Rational(r1 + r2)),
+            (Number::Rational(r1), Number::Rational(r2)) => {
+                Ok(Number::from(Rational::from(&*r1) + &*r2))
+            }
         }
     }
 }
@@ -423,9 +471,10 @@ impl Neg for Number {
 
     fn neg(self) -> Self::Output {
         match self {
-            Number::Integer(n) => Number::Integer(-n),
+            Number::Fixnum(n) => Number::Fixnum(-n),
+            Number::Integer(n) => Number::Integer(Rc::new(-Integer::from(&*n))),
             Number::Float(OrderedFloat(f)) => Number::Float(OrderedFloat(-f)),
-            Number::Rational(r) => Number::Rational(-r),
+            Number::Rational(r) => Number::Rational(Rc::new(-Rational::from(&*r))),
         }
     }
 }
@@ -443,14 +492,35 @@ impl Mul<Number> for Number {
 
     fn mul(self, rhs: Number) -> Self::Output {
         match (self, rhs) {
-            (Number::Integer(n1), Number::Integer(n2)) => Ok(Number::Integer(n1 * n2)), // mul_i
+            (Number::Fixnum(n1), Number::Fixnum(n2)) => {
+                Ok(if let Some(result) = n1.checked_mul(n2) {
+                    Number::Fixnum(result)
+                } else {
+                    Number::from(Integer::from(n1) * Integer::from(n2))
+                })
+            }
+            (Number::Fixnum(n1), Number::Integer(n2)) |
+            (Number::Integer(n2), Number::Fixnum(n1)) => {
+                Ok(Number::from(Integer::from(n1) * &*n2))
+            }
+            (Number::Fixnum(n1), Number::Rational(n2)) |
+            (Number::Rational(n2), Number::Fixnum(n1)) => {
+                Ok(Number::from(Rational::from(n1) * &*n2))
+            }
+            (Number::Fixnum(n1), Number::Float(OrderedFloat(n2))) |
+            (Number::Float(OrderedFloat(n2)), Number::Fixnum(n1)) => {
+                Ok(Number::Float(mul_f(float_fn_to_f(n1)?, n2)?))
+            }
+            (Number::Integer(n1), Number::Integer(n2)) => {
+                Ok(Number::Integer(Rc::new(Integer::from(&*n1) * &*n2))) // mul_i
+            }
             (Number::Integer(n1), Number::Float(OrderedFloat(n2)))
             | (Number::Float(OrderedFloat(n2)), Number::Integer(n1)) => {
                 Ok(Number::Float(mul_f(float_i_to_f(&n1)?, n2)?))
             }
             (Number::Integer(n1), Number::Rational(n2))
             | (Number::Rational(n2), Number::Integer(n1)) => {
-                Ok(Number::Rational(Rational::from(n1) * n2))
+                Ok(Number::Rational(Rc::new(Rational::from(&*n1) * &*n2)))
             }
             (Number::Rational(n1), Number::Float(OrderedFloat(n2)))
             | (Number::Float(OrderedFloat(n2)), Number::Rational(n1)) => {
@@ -459,7 +529,9 @@ impl Mul<Number> for Number {
             (Number::Float(OrderedFloat(f1)), Number::Float(OrderedFloat(f2))) => {
                 Ok(Number::Float(mul_f(f1, f2)?))
             }
-            (Number::Rational(r1), Number::Rational(r2)) => Ok(Number::Rational(r1 * r2)),
+            (Number::Rational(r1), Number::Rational(r2)) => {
+                Ok(Number::Rational(Rc::new(Rational::from(&*r1) * &*r2)))
+            }
         }
     }
 }
@@ -469,24 +541,72 @@ impl Div<Number> for Number {
 
     fn div(self, rhs: Number) -> Self::Output {
         match (self, rhs) {
-            (Number::Integer(n1), Number::Integer(n2)) => Ok(Number::Float(div_f(
-                float_i_to_f(&n1)?,
-                float_i_to_f(&n2)?,
-            )?)),
+            (Number::Fixnum(n1), Number::Fixnum(n2)) => {
+                Ok(Number::Float(div_f(
+                    float_fn_to_f(n1)?,
+                    float_fn_to_f(n2)?,
+                )?))
+            }
+            (Number::Fixnum(n1), Number::Integer(n2)) => {
+                Ok(Number::Float(div_f(
+                    float_fn_to_f(n1)?,
+                    float_i_to_f(&n2)?,
+                )?))
+            }
+            (Number::Integer(n1), Number::Fixnum(n2)) => {
+                Ok(Number::Float(div_f(
+                    float_i_to_f(&n1)?,
+                    float_fn_to_f(n2)?,
+                )?))
+            }
+            (Number::Fixnum(n1), Number::Rational(n2)) => {
+                Ok(Number::Float(div_f(
+                    float_fn_to_f(n1)?,
+                    float_r_to_f(&n2)?,
+                )?))
+            }
+            (Number::Rational(n1), Number::Fixnum(n2)) => {
+                Ok(Number::Float(div_f(
+                    float_r_to_f(&n1)?,
+                    float_fn_to_f(n2)?,
+                )?))
+            }
+            (Number::Fixnum(n1), Number::Float(OrderedFloat(n2))) => {
+                Ok(Number::Float(div_f(
+                    float_fn_to_f(n1)?,
+                    n2,
+                )?))
+            }
+            (Number::Float(OrderedFloat(n1)), Number::Fixnum(n2)) => {
+                Ok(Number::Float(div_f(
+                    n1,
+                    float_fn_to_f(n2)?,
+                )?))
+            }
+            (Number::Integer(n1), Number::Integer(n2)) => {
+                Ok(Number::Float(div_f(
+                    float_i_to_f(&n1)?,
+                    float_i_to_f(&n2)?,
+                )?))
+            }
             (Number::Integer(n1), Number::Float(OrderedFloat(n2))) => {
                 Ok(Number::Float(div_f(float_i_to_f(&n1)?, n2)?))
             }
             (Number::Float(OrderedFloat(n2)), Number::Integer(n1)) => {
                 Ok(Number::Float(div_f(n2, float_i_to_f(&n1)?)?))
             }
-            (Number::Integer(n1), Number::Rational(n2)) => Ok(Number::Float(div_f(
-                float_i_to_f(&n1)?,
-                float_r_to_f(&n2)?,
-            )?)),
-            (Number::Rational(n2), Number::Integer(n1)) => Ok(Number::Float(div_f(
-                float_r_to_f(&n2)?,
-                float_i_to_f(&n1)?,
-            )?)),
+            (Number::Integer(n1), Number::Rational(n2)) => {
+                Ok(Number::Float(div_f(
+                    float_i_to_f(&n1)?,
+                    float_r_to_f(&n2)?,
+                )?))
+            }
+            (Number::Rational(n2), Number::Integer(n1)) => {
+                Ok(Number::Float(div_f(
+                    float_r_to_f(&n2)?,
+                    float_i_to_f(&n1)?,
+                )?))
+            }
             (Number::Rational(n1), Number::Float(OrderedFloat(n2))) => {
                 Ok(Number::Float(div_f(float_r_to_f(&n1)?, n2)?))
             }
@@ -504,25 +624,47 @@ impl Div<Number> for Number {
     }
 }
 
+impl PartialEq for Number {
+    fn eq(&self, rhs: &Self) -> bool {
+        match (self, rhs) {
+            (&Number::Fixnum(n1), &Number::Fixnum(n2)) => n1.eq(&n2),
+            (&Number::Fixnum(n1), &Number::Integer(ref n2)) => n1.eq(&**n2),
+            (&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::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::Float(f1), &Number::Float(f2)) => f1.eq(&f2),
+            (&Number::Rational(ref r1), &Number::Rational(ref r2)) => r1.eq(&r2),
+        }
+    }
+}
+
+impl Eq for Number {}
+
 impl PartialOrd for Number {
     fn partial_cmp(&self, rhs: &Number) -> Option<Ordering> {
-        match (self, rhs) {
-            (&Number::Integer(ref n1), &Number::Integer(ref n2)) => Some(n1.cmp(n2)),
-            (&Number::Integer(_), Number::Float(_)) => Some(Ordering::Greater),
-            (&Number::Float(_), &Number::Integer(_)) => Some(Ordering::Less),
-            (&Number::Integer(_), &Number::Rational(_)) => Some(Ordering::Greater),
-            (&Number::Rational(_), &Number::Integer(_)) => Some(Ordering::Less),
-            (&Number::Rational(_), Number::Float(_)) => Some(Ordering::Greater),
-            (&Number::Float(_), &Number::Rational(_)) => Some(Ordering::Less),
-            (&Number::Float(f1), &Number::Float(f2)) => Some(f1.cmp(&f2)),
-            (&Number::Rational(ref r1), &Number::Rational(ref r2)) => Some(r1.cmp(&r2)),
-        }
+        Some(self.cmp(rhs))
     }
 }
 
 impl Ord for Number {
     fn cmp(&self, rhs: &Number) -> Ordering {
         match (self, rhs) {
+            (&Number::Fixnum(n1), &Number::Fixnum(n2)) => n1.cmp(&n2),
+            (&Number::Fixnum(n1), Number::Integer(n2)) => Integer::from(n1).cmp(&*n2),
+            (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::Integer(ref n1), &Number::Integer(ref n2)) => n1.cmp(n2),
             (&Number::Integer(_), Number::Float(_)) => Ordering::Greater,
             (&Number::Float(_), &Number::Integer(_)) => Ordering::Less,
@@ -536,9 +678,81 @@ impl Ord for Number {
     }
 }
 
+impl<'a> TryFrom<(Addr, &'a Heap)> for Number {
+    type Error = ();
+
+    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))
+            }
+            Addr::Float(n) => {
+                Ok(Number::Float(n))
+            }
+            Addr::Usize(n) => {
+                if let Ok(n) = isize::try_from(n) {
+                    Ok(Number::from(n))
+                } else {
+                    Ok(Number::from(Integer::from(n)))
+                }
+            }
+            Addr::Con(h) => {
+                Number::try_from(&heap[h])
+            }
+            _ => {
+                Err(())
+            }
+        }
+    }
+}
+
+impl<'a> TryFrom<&'a HeapCellValue> for Number {
+    type Error = ();
+
+    fn try_from(value: &'a HeapCellValue) -> Result<Number, Self::Error> {
+        match value {
+            HeapCellValue::Addr(addr) => {
+                match addr {
+                    &Addr::CharCode(c) => {
+                        Ok(Number::from(c as isize))
+                    }
+                    &Addr::Fixnum(n) => {
+                        Ok(Number::from(n))
+                    }
+                    &Addr::Float(n) => {
+                        Ok(Number::Float(n))
+                    }
+                    &Addr::Usize(n) => {
+                        if let Ok(n) = isize::try_from(n) {
+                            Ok(Number::from(n))
+                        } else {
+                            Ok(Number::from(Integer::from(n)))
+                        }
+                    }
+                    _ => {
+                        Err(())
+                    }
+                }
+            }
+            HeapCellValue::Integer(n) => {
+                Ok(Number::Integer(n.clone()))
+            }
+            HeapCellValue::Rational(n) => {
+                Ok(Number::Rational(n.clone()))
+            }
+            _ => {
+                Err(())
+            }
+        }
+    }
+}
+
 // Computes n ^ power. Ignores the sign of power.
-pub fn binary_pow(mut n: Integer, power: Integer) -> Integer {
-    let mut power = power.abs();
+pub fn binary_pow(mut n: Integer, power: &Integer) -> Integer {
+    let mut power = Integer::from(power.abs_ref());
 
     if power == 0 {
         return Integer::from(1);

src/prolog/clause_types.rs

@@ -2,6 +2,7 @@ use prolog_parser::ast::*;
 
 use crate::prolog::forms::Number;
 use crate::prolog::machine::machine_indices::*;
+use crate::prolog::rug::rand::RandState;
 
 use ref_thread_local::RefThreadLocal;
 
@@ -74,13 +75,15 @@ pub enum InlinedClauseType {
     IsCompound(RegType),
     IsInteger(RegType),
     IsRational(RegType),
-    IsString(RegType),
     IsFloat(RegType),
     IsNonVar(RegType),
-    IsPartialString(RegType),
     IsVar(RegType),
 }
 
+ref_thread_local! {
+    pub static managed RANDOM_STATE: RandState<'static> = RandState::new();
+}
+
 ref_thread_local! {
     pub static managed CLAUSE_TYPE_FORMS: BTreeMap<(&'static str, usize), ClauseType> = {
         let mut m = BTreeMap::new();
@@ -101,10 +104,8 @@ ref_thread_local! {
         m.insert(("compound", 1), ClauseType::Inlined(InlinedClauseType::IsCompound(r1)));
         m.insert(("integer", 1), ClauseType::Inlined(InlinedClauseType::IsInteger(r1)));
         m.insert(("rational", 1), ClauseType::Inlined(InlinedClauseType::IsRational(r1)));
-        m.insert(("string", 1), ClauseType::Inlined(InlinedClauseType::IsString(r1)));
         m.insert(("float", 1), ClauseType::Inlined(InlinedClauseType::IsFloat(r1)));
         m.insert(("nonvar", 1), ClauseType::Inlined(InlinedClauseType::IsNonVar(r1)));
-        m.insert(("is_partial_string", 1), ClauseType::Inlined(InlinedClauseType::IsPartialString(r1)));
         m.insert(("var", 1), ClauseType::Inlined(InlinedClauseType::IsVar(r1)));
         m.insert(("acyclic_term", 1), ClauseType::BuiltIn(BuiltInClauseType::AcyclicTerm));
         m.insert(("arg", 3), ClauseType::BuiltIn(BuiltInClauseType::Arg));
@@ -114,7 +115,6 @@ ref_thread_local! {
         m.insert(("@>=", 2), ClauseType::BuiltIn(BuiltInClauseType::CompareTerm(CompareTermQT::GreaterThanOrEqual)));
         m.insert(("@=<", 2), ClauseType::BuiltIn(BuiltInClauseType::CompareTerm(CompareTermQT::LessThanOrEqual)));
         m.insert(("copy_term", 2), ClauseType::BuiltIn(BuiltInClauseType::CopyTerm));
-        m.insert(("cyclic_term", 1), ClauseType::BuiltIn(BuiltInClauseType::CyclicTerm));
         m.insert(("==", 2), ClauseType::BuiltIn(BuiltInClauseType::Eq));
         m.insert(("functor", 3), ClauseType::BuiltIn(BuiltInClauseType::Functor));
         m.insert(("ground", 1), ClauseType::BuiltIn(BuiltInClauseType::Ground));
@@ -122,7 +122,6 @@ ref_thread_local! {
         m.insert(("keysort", 2), ClauseType::BuiltIn(BuiltInClauseType::KeySort));
         m.insert(("nl", 0), ClauseType::BuiltIn(BuiltInClauseType::Nl));
         m.insert(("\\==", 2), ClauseType::BuiltIn(BuiltInClauseType::NotEq));
-        m.insert(("partial_string", 2), ClauseType::BuiltIn(BuiltInClauseType::PartialString));
         m.insert(("read", 1), ClauseType::BuiltIn(BuiltInClauseType::Read));
         m.insert(("sort", 2), ClauseType::BuiltIn(BuiltInClauseType::Sort));
 
@@ -139,10 +138,8 @@ impl InlinedClauseType {
             &InlinedClauseType::IsCompound(..) => "compound",
             &InlinedClauseType::IsInteger(..) => "integer",
             &InlinedClauseType::IsRational(..) => "rational",
-            &InlinedClauseType::IsString(..) => "string",
             &InlinedClauseType::IsFloat(..) => "float",
             &InlinedClauseType::IsNonVar(..) => "nonvar",
-            &InlinedClauseType::IsPartialString(..) => "is_partial_string",
             &InlinedClauseType::IsVar(..) => "var",
         }
     }
@@ -154,19 +151,26 @@ pub enum SystemClauseType {
     AbolishModuleClause,
     AssertDynamicPredicateToBack,
     AssertDynamicPredicateToFront,
+    AtEndOfExpansion,
     AtomChars,
     AtomCodes,
     AtomLength,
-    ModuleAssertDynamicPredicateToFront,
-    ModuleAssertDynamicPredicateToBack,
+    BindFromRegister,
+    CallContinuation,
     CharCode,
     CharsToNumber,
+    ClearAttributeGoals,
+    CloneAttributeGoals,
     CodesToNumber,
+    CopyTermWithoutAttrVars,
     CheckCutPoint,
     CopyToLiftedHeap,
+    CreatePartialString,
+    CurrentInput,
+    CurrentOutput,
     DeleteAttribute,
     DeleteHeadAttribute,
-    DynamicModuleResolution,
+    DynamicModuleResolution(usize),
     EnqueueAttributeGoal,
     EnqueueAttributedVar,
     ExpandGoal,
@@ -174,6 +178,7 @@ pub enum SystemClauseType {
     FetchGlobalVar,
     FetchGlobalVarWithOffset,
     GetChar,
+    ResetAttrVarState,
     TruncateIfNoLiftedHeapGrowthDiff,
     TruncateIfNoLiftedHeapGrowth,
     GetAttributedVariableList,
@@ -181,9 +186,11 @@ pub enum SystemClauseType {
     GetAttrVarQueueBeyond,
     GetBValue,
     GetClause,
+    GetContinuationChunk,
     GetModuleClause,
     GetNextDBRef,
     GetNextOpDBRef,
+    IsPartialString,
     LookupDBRef,
     LookupOpDBRef,
     Halt,
@@ -195,23 +202,32 @@ pub enum SystemClauseType {
     InstallSCCCleaner,
     InstallInferenceCounter,
     LiftedHeapLength,
+    ModuleAssertDynamicPredicateToFront,
+    ModuleAssertDynamicPredicateToBack,
+    ModuleExists,
     ModuleOf,
     ModuleRetractClause,
+    NextEP,
     NoSuchPredicate,
     NumberToChars,
     NumberToCodes,
     OpDeclaration,
+    PartialStringTail,
+    PointsToContinuationResetMarker,
     REPL(REPLCodePtr),
     ReadQueryTerm,
     ReadTerm,
-    RedoAttrVarBindings,
+    RedoAttrVarBinding,
     RemoveCallPolicyCheck,
     RemoveInferenceCounter,
+    ResetContinuationMarker,
     ResetGlobalVarAtKey,
     ResetGlobalVarAtOffset,
     RetractClause,
     RestoreCutPolicy,
     SetCutPoint(RegType),
+    SetInput,
+    SetOutput,
     StoreGlobalVar,
     StoreGlobalVarWithOffset,
     InferenceLevel,
@@ -223,21 +239,27 @@ pub enum SystemClauseType {
     GetCutPoint,
     GetDoubleQuotes,
     InstallNewBlock,
+    Maybe,
+    QuotedToken,
+    RawInputReadChar,
+    ReadTermFromChars,
     ResetBlock,
-    ReturnFromAttributeGoals,
     ReturnFromVerifyAttr,
     SetBall,
     SetCutPointByDefault(RegType),
     SetDoubleQuotes,
+    SetSeed,
     SkipMaxList,
     Succeed,
     TermVariables,
     TruncateLiftedHeapTo,
     UnifyWithOccursCheck,
+    UnwindEnvironments,
     UnwindStack,
     Variant,
     WAMInstructions,
     WriteTerm,
+    WriteTermToChars,
 }
 
 impl SystemClauseType {
@@ -247,37 +269,37 @@ impl SystemClauseType {
             &SystemClauseType::AbolishModuleClause => clause_name!("$abolish_module_clause"),
             &SystemClauseType::AssertDynamicPredicateToBack => clause_name!("$assertz"),
             &SystemClauseType::AssertDynamicPredicateToFront => clause_name!("$asserta"),
+            &SystemClauseType::AtEndOfExpansion => clause_name!("$at_end_of_expansion"),
             &SystemClauseType::AtomChars => clause_name!("$atom_chars"),
             &SystemClauseType::AtomCodes => clause_name!("$atom_codes"),
             &SystemClauseType::AtomLength => clause_name!("$atom_length"),
-            &SystemClauseType::ModuleAssertDynamicPredicateToFront => {
-                clause_name!("$module_asserta")
-            }
-            &SystemClauseType::ModuleAssertDynamicPredicateToBack => {
-                clause_name!("$module_assertz")
-            }
+            &SystemClauseType::BindFromRegister => clause_name!("$bind_from_register"),
+            &SystemClauseType::CallContinuation => clause_name!("$call_continuation"),
             &SystemClauseType::CharCode => clause_name!("$char_code"),
             &SystemClauseType::CharsToNumber => clause_name!("$chars_to_number"),
-            &SystemClauseType::CodesToNumber => clause_name!("$codes_to_number"),
             &SystemClauseType::CheckCutPoint => clause_name!("$check_cp"),
+            &SystemClauseType::ClearAttributeGoals => clause_name!("$clear_attribute_goals"),
+            &SystemClauseType::CloneAttributeGoals => clause_name!("$clone_attribute_goals"),
+            &SystemClauseType::CodesToNumber => clause_name!("$codes_to_number"),
+            &SystemClauseType::CopyTermWithoutAttrVars => clause_name!("$copy_term_without_attr_vars"),
+            &SystemClauseType::CreatePartialString => clause_name!("$create_partial_string"),
+            &SystemClauseType::CurrentInput => clause_name!("$current_input"),
+            &SystemClauseType::CurrentOutput => clause_name!("$current_output"),
             &SystemClauseType::REPL(REPLCodePtr::CompileBatch) => clause_name!("$compile_batch"),
-            &SystemClauseType::REPL(REPLCodePtr::SubmitQueryAndPrintResults) => {
-                clause_name!("$submit_query_and_print_results")
-            }
-	    &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::CopyToLiftedHeap => clause_name!("$copy_to_lh"),
             &SystemClauseType::DeleteAttribute => clause_name!("$del_attr_non_head"),
             &SystemClauseType::DeleteHeadAttribute => clause_name!("$del_attr_head"),
-            &SystemClauseType::DynamicModuleResolution => clause_name!("$module_call"),
+            &SystemClauseType::DynamicModuleResolution(_) => clause_name!("$module_call"),
             &SystemClauseType::EnqueueAttributeGoal => clause_name!("$enqueue_attribute_goal"),
             &SystemClauseType::EnqueueAttributedVar => clause_name!("$enqueue_attr_var"),
             &SystemClauseType::ExpandTerm => clause_name!("$expand_term"),
@@ -287,6 +309,7 @@ impl SystemClauseType {
                 clause_name!("$fetch_global_var_with_offset")
             }
             &SystemClauseType::GetChar => clause_name!("$get_char"),
+            &SystemClauseType::ResetAttrVarState => clause_name!("$reset_attr_var_state"),
             &SystemClauseType::TruncateIfNoLiftedHeapGrowth => {
                 clause_name!("$truncate_if_no_lh_growth")
             }
@@ -298,6 +321,7 @@ impl SystemClauseType {
                 clause_name!("$get_attr_var_queue_delim")
             }
             &SystemClauseType::GetAttrVarQueueBeyond => clause_name!("$get_attr_var_queue_beyond"),
+            &SystemClauseType::GetContinuationChunk => clause_name!("$get_cont_chunk"),
             &SystemClauseType::GetLiftedHeapFromOffset => clause_name!("$get_lh_from_offset"),
             &SystemClauseType::GetLiftedHeapFromOffsetDiff => {
                 clause_name!("$get_lh_from_offset_diff")
@@ -318,17 +342,37 @@ impl SystemClauseType {
             &SystemClauseType::InstallInferenceCounter => {
                 clause_name!("$install_inference_counter")
             }
+            &SystemClauseType::IsPartialString => clause_name!("$is_partial_string"),
+            &SystemClauseType::PartialStringTail => clause_name!("$partial_string_tail"),
             &SystemClauseType::LiftedHeapLength => clause_name!("$lh_length"),
+            &SystemClauseType::Maybe => clause_name!("maybe"),
+            &SystemClauseType::ModuleAssertDynamicPredicateToFront => {
+                clause_name!("$module_asserta")
+            }
+            &SystemClauseType::ModuleAssertDynamicPredicateToBack => {
+                clause_name!("$module_assertz")
+            }
             &SystemClauseType::ModuleHeadIsDynamic => clause_name!("$module_head_is_dynamic"),
+            &SystemClauseType::ModuleExists => clause_name!("$module_exists"),
             &SystemClauseType::ModuleOf => clause_name!("$module_of"),
             &SystemClauseType::NoSuchPredicate => clause_name!("$no_such_predicate"),
             &SystemClauseType::NumberToChars => clause_name!("$number_to_chars"),
             &SystemClauseType::NumberToCodes => clause_name!("$number_to_codes"),
-            &SystemClauseType::RedoAttrVarBindings => clause_name!("$redo_attr_var_bindings"),
+            &SystemClauseType::PointsToContinuationResetMarker => {
+                clause_name!("$points_to_cont_reset_marker")
+            }
+            &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"),
             &SystemClauseType::RestoreCutPolicy => clause_name!("$restore_cut_policy"),
             &SystemClauseType::SetCutPoint(_) => clause_name!("$set_cp"),
+            &SystemClauseType::SetInput => clause_name!("$set_input"),
+            &SystemClauseType::SetOutput => clause_name!("$set_output"),
+            &SystemClauseType::SetSeed => clause_name!("$set_seed"),
             &SystemClauseType::StoreGlobalVar => clause_name!("$store_global_var"),
             &SystemClauseType::StoreGlobalVarWithOffset => {
                 clause_name!("$store_global_var_with_offset")
@@ -342,15 +386,15 @@ impl SystemClauseType {
             &SystemClauseType::GetCurrentBlock => clause_name!("$get_current_block"),
             &SystemClauseType::InstallNewBlock => clause_name!("$install_new_block"),
             &SystemClauseType::ModuleRetractClause => clause_name!("$module_retract_clause"),
+            &SystemClauseType::NextEP => clause_name!("$nextEP"),
             &SystemClauseType::ReadQueryTerm => clause_name!("$read_query_term"),
             &SystemClauseType::ReadTerm => clause_name!("$read_term"),
+            &SystemClauseType::ReadTermFromChars => clause_name!("$read_term_from_chars"),
             &SystemClauseType::ResetGlobalVarAtKey => clause_name!("$reset_global_var_at_key"),
             &SystemClauseType::ResetGlobalVarAtOffset => clause_name!("$reset_global_var_at_offset"),
             &SystemClauseType::RetractClause => clause_name!("$retract_clause"),
             &SystemClauseType::ResetBlock => clause_name!("$reset_block"),
-            &SystemClauseType::ReturnFromAttributeGoals => {
-                clause_name!("$return_from_attribute_goals")
-            }
+            &SystemClauseType::ResetContinuationMarker => clause_name!("$reset_cont_marker"),
             &SystemClauseType::ReturnFromVerifyAttr => clause_name!("$return_from_verify_attr"),
             &SystemClauseType::SetBall => clause_name!("$set_ball"),
             &SystemClauseType::SetCutPointByDefault(_) => clause_name!("$set_cp_by_default"),
@@ -360,44 +404,61 @@ impl SystemClauseType {
             &SystemClauseType::TermVariables => clause_name!("$term_variables"),
             &SystemClauseType::TruncateLiftedHeapTo => clause_name!("$truncate_lh_to"),
             &SystemClauseType::UnifyWithOccursCheck => clause_name!("$unify_with_occurs_check"),
+            &SystemClauseType::UnwindEnvironments => clause_name!("$unwind_environments"),
             &SystemClauseType::UnwindStack => clause_name!("$unwind_stack"),
             &SystemClauseType::Variant => clause_name!("$variant"),
             &SystemClauseType::WAMInstructions => clause_name!("$wam_instructions"),
             &SystemClauseType::WriteTerm => clause_name!("$write_term"),
+            &SystemClauseType::WriteTermToChars => clause_name!("$write_term_to_chars"),
         }
     }
 
     pub fn from(name: &str, arity: usize) -> Option<SystemClauseType> {
         match (name, arity) {
             ("$abolish_clause", 2) => Some(SystemClauseType::AbolishClause),
+            ("$at_end_of_expansion", 0) => Some(SystemClauseType::AtEndOfExpansion),
             ("$atom_chars", 2) => Some(SystemClauseType::AtomChars),
             ("$atom_codes", 2) => Some(SystemClauseType::AtomCodes),
             ("$atom_length", 2) => Some(SystemClauseType::AtomLength),
             ("$abolish_module_clause", 3) => Some(SystemClauseType::AbolishModuleClause),
+            ("$bind_from_register", 2) => Some(SystemClauseType::BindFromRegister),
             ("$module_asserta", 5) => Some(SystemClauseType::ModuleAssertDynamicPredicateToFront),
             ("$module_assertz", 5) => Some(SystemClauseType::ModuleAssertDynamicPredicateToBack),
             ("$asserta", 4) => Some(SystemClauseType::AssertDynamicPredicateToFront),
             ("$assertz", 4) => Some(SystemClauseType::AssertDynamicPredicateToBack),
+            ("$call_continuation", 1) => Some(SystemClauseType::CallContinuation),
             ("$char_code", 2) => Some(SystemClauseType::CharCode),
             ("$chars_to_number", 2) => Some(SystemClauseType::CharsToNumber),
+            ("$clear_attribute_goals", 0) => Some(SystemClauseType::ClearAttributeGoals),
+            ("$clone_attribute_goals", 1) => Some(SystemClauseType::CloneAttributeGoals),
             ("$codes_to_number", 2) => Some(SystemClauseType::CodesToNumber),
+            ("$copy_term_without_attr_vars", 2) => Some(SystemClauseType::CopyTermWithoutAttrVars),
+            ("$create_partial_string", 3) => Some(SystemClauseType::CreatePartialString),
             ("$check_cp", 1) => Some(SystemClauseType::CheckCutPoint),
             ("$compile_batch", 0) => Some(SystemClauseType::REPL(REPLCodePtr::CompileBatch)),
             ("$copy_to_lh", 2) => Some(SystemClauseType::CopyToLiftedHeap),
+            ("$current_input", 1) => Some(SystemClauseType::CurrentInput),
+            ("$current_output", 1) => Some(SystemClauseType::CurrentOutput),
             ("$del_attr_non_head", 1) => Some(SystemClauseType::DeleteAttribute),
             ("$del_attr_head", 1) => Some(SystemClauseType::DeleteHeadAttribute),
             ("$get_next_db_ref", 2) => Some(SystemClauseType::GetNextDBRef),
             ("$get_next_op_db_ref", 2) => Some(SystemClauseType::GetNextOpDBRef),
             ("$lookup_db_ref", 3) => Some(SystemClauseType::LookupDBRef),
             ("$lookup_op_db_ref", 4) => Some(SystemClauseType::LookupOpDBRef),
-            ("$module_call", 2) => Some(SystemClauseType::DynamicModuleResolution),
+            ("$module_call", _) => Some(SystemClauseType::DynamicModuleResolution(arity - 2)),
             ("$enqueue_attribute_goal", 1) => Some(SystemClauseType::EnqueueAttributeGoal),
             ("$enqueue_attr_var", 1) => Some(SystemClauseType::EnqueueAttributedVar),
+            ("$partial_string_tail", 2) => Some(SystemClauseType::PartialStringTail),
+            ("$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),
+            ("$points_to_cont_reset_marker", 1) => {
+                Some(SystemClauseType::PointsToContinuationResetMarker)
+            }
+            ("$reset_attr_var_state", 0) => Some(SystemClauseType::ResetAttrVarState),
             ("$truncate_if_no_lh_growth", 1) => {
                 Some(SystemClauseType::TruncateIfNoLiftedHeapGrowth)
             }
@@ -417,6 +478,8 @@ impl SystemClauseType {
             ("$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),
+            ("$module_exists", 1) => Some(SystemClauseType::ModuleExists),
             ("$module_of", 2) => Some(SystemClauseType::ModuleOf),
             ("$module_retract_clause", 5) => Some(SystemClauseType::ModuleRetractClause),
             ("$module_head_is_dynamic", 2) => Some(SystemClauseType::ModuleHeadIsDynamic),
@@ -424,11 +487,13 @@ impl SystemClauseType {
             ("$number_to_chars", 2) => Some(SystemClauseType::NumberToChars),
             ("$number_to_codes", 2) => Some(SystemClauseType::NumberToCodes),
             ("$op", 3) => Some(SystemClauseType::OpDeclaration),
-            ("$redo_attr_var_bindings", 0) => Some(SystemClauseType::RedoAttrVarBindings),
+            ("$redo_attr_var_binding", 2) => Some(SystemClauseType::RedoAttrVarBinding),
             ("$remove_call_policy_check", 1) => Some(SystemClauseType::RemoveCallPolicyCheck),
             ("$remove_inference_counter", 2) => Some(SystemClauseType::RemoveInferenceCounter),
             ("$restore_cut_policy", 0) => Some(SystemClauseType::RestoreCutPolicy),
             ("$set_cp", 1) => Some(SystemClauseType::SetCutPoint(temp_v!(1))),
+            ("$set_input", 1) => Some(SystemClauseType::SetInput),
+            ("$set_output", 1) => Some(SystemClauseType::SetOutput),
             ("$inference_level", 2) => Some(SystemClauseType::InferenceLevel),
             ("$clean_up_block", 1) => Some(SystemClauseType::CleanUpBlock),
             ("$erase_ball", 0) => Some(SystemClauseType::EraseBall),
@@ -436,40 +501,45 @@ impl SystemClauseType {
             ("$get_attr_var_queue_beyond", 2) => Some(SystemClauseType::GetAttrVarQueueBeyond),
             ("$get_attr_var_queue_delim", 1) => Some(SystemClauseType::GetAttrVarQueueDelimiter),
             ("$get_ball", 1) => Some(SystemClauseType::GetBall),
+            ("$get_cont_chunk", 3) => Some(SystemClauseType::GetContinuationChunk),
             ("$get_current_block", 1) => Some(SystemClauseType::GetCurrentBlock),
             ("$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_term_from_chars", 2) => Some(SystemClauseType::ReadTermFromChars),
             ("$reset_block", 1) => Some(SystemClauseType::ResetBlock),
+            ("$reset_cont_marker", 0) => Some(SystemClauseType::ResetContinuationMarker),
             ("$reset_global_var_at_key", 1) => Some(SystemClauseType::ResetGlobalVarAtKey),
             ("$reset_global_var_at_offset", 3) => Some(SystemClauseType::ResetGlobalVarAtOffset),
             ("$retract_clause", 4) => Some(SystemClauseType::RetractClause),
-            ("$return_from_attribute_goals", 0) => Some(SystemClauseType::ReturnFromAttributeGoals),
             ("$return_from_verify_attr", 0) => Some(SystemClauseType::ReturnFromVerifyAttr),
             ("$set_ball", 1) => Some(SystemClauseType::SetBall),
             ("$set_cp_by_default", 1) => Some(SystemClauseType::SetCutPointByDefault(temp_v!(1))),
             ("$set_double_quotes", 1) => Some(SystemClauseType::SetDoubleQuotes),
+            ("$set_seed", 1) => Some(SystemClauseType::SetSeed),
             ("$skip_max_list", 4) => Some(SystemClauseType::SkipMaxList),
             ("$store_global_var", 2) => Some(SystemClauseType::StoreGlobalVar),
             ("$store_global_var_with_offset", 2) => Some(SystemClauseType::StoreGlobalVarWithOffset),
-            ("$submit_query_and_print_results", 2) => Some(SystemClauseType::REPL(
-                REPLCodePtr::SubmitQueryAndPrintResults,
-            )),
             ("$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)),
+	        ("$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),
-            ("$write_term", 5) => Some(SystemClauseType::WriteTerm),
             ("$wam_instructions", 3) => Some(SystemClauseType::WAMInstructions),
+            ("$write_term", 6) => Some(SystemClauseType::WriteTerm),
+            ("$write_term_to_chars", 7) => Some(SystemClauseType::WriteTermToChars),
             _ => None,
         }
     }
@@ -481,7 +551,6 @@ pub enum BuiltInClauseType {
     Arg,
     Compare,
     CompareTerm(CompareTermQT),
-    CyclicTerm,
     CopyTerm,
     Eq,
     Functor,
@@ -490,7 +559,6 @@ pub enum BuiltInClauseType {
     KeySort,
     Nl,
     NotEq,
-    PartialString,
     Read,
     Sort,
 }
@@ -513,7 +581,6 @@ impl BuiltInClauseType {
             &BuiltInClauseType::Arg => clause_name!("arg"),
             &BuiltInClauseType::Compare => clause_name!("compare"),
             &BuiltInClauseType::CompareTerm(qt) => clause_name!(qt.name()),
-            &BuiltInClauseType::CyclicTerm => clause_name!("cyclic_term"),
             &BuiltInClauseType::CopyTerm => clause_name!("copy_term"),
             &BuiltInClauseType::Eq => clause_name!("=="),
             &BuiltInClauseType::Functor => clause_name!("functor"),
@@ -522,7 +589,6 @@ impl BuiltInClauseType {
             &BuiltInClauseType::KeySort => clause_name!("keysort"),
             &BuiltInClauseType::Nl => clause_name!("nl"),
             &BuiltInClauseType::NotEq => clause_name!("\\=="),
-            &BuiltInClauseType::PartialString => clause_name!("partial_string"),
             &BuiltInClauseType::Read => clause_name!("read"),
             &BuiltInClauseType::Sort => clause_name!("sort"),
         }
@@ -534,7 +600,6 @@ impl BuiltInClauseType {
             &BuiltInClauseType::Arg => 3,
             &BuiltInClauseType::Compare => 2,
             &BuiltInClauseType::CompareTerm(_) => 2,
-            &BuiltInClauseType::CyclicTerm => 1,
             &BuiltInClauseType::CopyTerm => 2,
             &BuiltInClauseType::Eq => 2,
             &BuiltInClauseType::Functor => 3,
@@ -543,7 +608,6 @@ impl BuiltInClauseType {
             &BuiltInClauseType::KeySort => 2,
             &BuiltInClauseType::NotEq => 2,
             &BuiltInClauseType::Nl => 0,
-            &BuiltInClauseType::PartialString => 1,
             &BuiltInClauseType::Read => 1,
             &BuiltInClauseType::Sort => 2,
         }
@@ -565,8 +629,8 @@ impl ClauseType {
 
     pub fn name(&self) -> ClauseName {
         match self {
-            &ClauseType::CallN => clause_name!("call"),
             &ClauseType::BuiltIn(ref built_in) => built_in.name(),
+            &ClauseType::CallN => clause_name!("call"),
             &ClauseType::Hook(ref hook) => hook.name(),
             &ClauseType::Inlined(ref inlined) => clause_name!(inlined.name()),
             &ClauseType::Op(ref name, ..) => name.clone(),

src/prolog/codegen.rs

@@ -11,14 +11,13 @@ use crate::prolog::iterators::*;
 use crate::prolog::machine::machine_indices::*;
 use crate::prolog::targets::*;
 
-use indexmap::IndexMap;
+use indexmap::{IndexMap, IndexSet};
 
 use std::cell::Cell;
 use std::rc::Rc;
 use std::vec::Vec;
 
 pub struct CodeGenerator<TermMarker> {
-    flags: MachineFlags,
     marker: TermMarker,
     pub var_count: IndexMap<Rc<Var>, usize>,
     non_counted_bt: bool,
@@ -51,68 +50,56 @@ impl<'a> ConjunctInfo<'a> {
         self.has_deep_cut as usize
     }
 
-    fn mark_unsafe_vars<Alloc: Allocator<'a>>(
+    fn mark_unsafe_vars(
         &self,
         mut unsafe_var_marker: UnsafeVarMarker,
-        marker: &Alloc,
-        code: &mut Code
+        code: &mut Code,
     ) {
-        // target the last goal of the rule for handling unsafe variables.
-        // we use this weird logic to find the last goal.
-        let right_index = if let Some(Line::Control(_)) = code.last() {
-            if code.len() >= 2 {
-                code.len() - 2
-            } else {
-                return;
-            }
-        } else {
-            if code.len() >= 1 {
-                code.len() - 1
-            } else {
-                return;
-            }
-        };
+        if code.is_empty() {
+            return;
+        }
 
-        let mut index = right_index;
+        let mut code_index = 0;
 
-        if let Line::Query(_) = &code[right_index] {
-            while let Line::Query(_) = &code[index] {
-                if index == 0 {
-                    break;
-                } else {
-                    index -= 1;
+        for phase in 0 .. {
+            while let Line::Query(ref query_instr) = &code[code_index] {
+                if !unsafe_var_marker.mark_safe_vars(query_instr) {
+                    unsafe_var_marker.mark_phase(query_instr, phase);
                 }
+
+                code_index += 1;
             }
 
-            if let Line::Query(_) = &code[index] {
+            if code_index + 1 < code.len() {
+                code_index += 1;
             } else {
-                index += 1;
+                break;
+            }
+        }
+
+        code_index = 0;
+
+        for phase in 0 .. {
+            while let Line::Query(ref mut query_instr) = &mut code[code_index] {
+                unsafe_var_marker.mark_unsafe_vars(query_instr, phase);
+                code_index += 1;
             }
 
-            unsafe_var_marker.record_unsafe_vars(&self.perm_vs, marker);
-
-            for line in code.iter() {
-                if let Line::Query(ref query_instr) = line {
-                    unsafe_var_marker.mark_safe_vars(query_instr);
-                }
-            }
-
-            for index in index..right_index + 1 {
-                if let &mut Line::Query(ref mut query_instr) = &mut code[index] {
-                    unsafe_var_marker.mark_unsafe_vars(query_instr);
-                }
+            if code_index + 1 < code.len() {
+                code_index += 1;
+            } else {
+                break;
             }
         }
     }
 }
 
 impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
-    pub fn new(non_counted_bt: bool, flags: MachineFlags) -> Self {
+    pub fn new(non_counted_bt: bool) -> Self {
         CodeGenerator {
             marker: Allocator::new(),
             var_count: IndexMap::new(),
             non_counted_bt,
-            flags,
         }
     }
 
@@ -176,40 +163,49 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
         target.push(Target::to_void(1));
     }
 
-    fn subterm_to_instr<Target>(
+    fn deep_var_instr<Target: CompilationTarget<'a>>(
+        &mut self,
+        cell: &'a Cell<VarReg>,
+        var: &'a Rc<Var>,
+        term_loc: GenContext,
+        is_exposed: bool,
+        target: &mut Vec<Target>,
+    ) {
+        if is_exposed || self.get_var_count(var.as_ref()) > 1 {
+            self.marker.mark_var(var.clone(), Level::Deep, cell, term_loc, target);
+        } else {
+            Self::add_or_increment_void_instr(target);
+        }
+    }
+
+    fn subterm_to_instr<Target: CompilationTarget<'a>>(
         &mut self,
         subterm: &'a Term,
         term_loc: GenContext,
         is_exposed: bool,
         target: &mut Vec<Target>,
-    ) where
-        Target: CompilationTarget<'a>,
-    {
+    ) {
         match subterm {
             &Term::AnonVar if is_exposed => {
-                self.marker.mark_anon_var(Level::Deep, term_loc, target)
+                self.marker.mark_anon_var(Level::Deep, term_loc, target);
+            }
+            &Term::AnonVar => {
+                Self::add_or_increment_void_instr(target);
             }
-            &Term::AnonVar => Self::add_or_increment_void_instr(target),
             &Term::Cons(ref cell, _, _) | &Term::Clause(ref cell, _, _, _) => {
-                self.marker
-                    .mark_non_var(Level::Deep, term_loc, cell, target);
+                self.marker.mark_non_var(Level::Deep, term_loc, cell, target);
                 target.push(Target::clause_arg_to_instr(cell.get()));
             }
             &Term::Constant(_, ref constant) => {
-                target.push(Target::constant_subterm(constant.clone()))
+                target.push(Target::constant_subterm(constant.clone()));
             }
             &Term::Var(ref cell, ref var) => {
-                if is_exposed || self.get_var_count(var) > 1 {
-                    self.marker
-                        .mark_var(var.clone(), Level::Deep, cell, term_loc, target);
-                } else {
-                    Self::add_or_increment_void_instr(target);
-                }
+                self.deep_var_instr(cell, var, term_loc, is_exposed, target);
             }
         };
     }
 
-    fn compile_target<Target, Iter>(
+     fn compile_target<Target, Iter>(
         &mut self,
         iter: Iter,
         term_loc: GenContext,
@@ -223,6 +219,13 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
 
         for term in iter {
             match term {
+                TermRef::AnonVar(lvl @ Level::Shallow) => {
+                    if let GenContext::Head = term_loc {
+                        self.marker.advance_arg();
+                    } else {
+                        self.marker.mark_anon_var(lvl, term_loc, &mut target);
+                    }
+                }
                 TermRef::Clause(lvl, cell, ct, terms) => {
                     self.marker.mark_non_var(lvl, term_loc, cell, &mut target);
                     target.push(Target::to_structure(ct, terms.len(), cell.get()));
@@ -238,15 +241,22 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                     self.subterm_to_instr(head, term_loc, is_exposed, &mut target);
                     self.subterm_to_instr(tail, term_loc, is_exposed, &mut target);
                 }
+                TermRef::Constant(lvl @ Level::Shallow, cell, Constant::String(ref string)) => {
+                    self.marker.mark_non_var(lvl, term_loc, cell, &mut target);
+                    target.push(Target::to_pstr(lvl, string.to_string(), cell.get(), false));
+                }
                 TermRef::Constant(lvl @ Level::Shallow, cell, constant) => {
                     self.marker.mark_non_var(lvl, term_loc, cell, &mut target);
                     target.push(Target::to_constant(lvl, constant.clone(), cell.get()));
                 }
-                TermRef::AnonVar(lvl @ Level::Shallow) => {
-                    if let GenContext::Head = term_loc {
-                        self.marker.advance_arg();
+                TermRef::PartialString(lvl, cell, string, tail) => {
+                    self.marker.mark_non_var(lvl, term_loc, cell, &mut target);
+
+                    if let Some(tail) = tail {
+                        target.push(Target::to_pstr(lvl, string, cell.get(), true));
+                        self.subterm_to_instr(tail, term_loc, is_exposed, &mut target);
                     } else {
-                        self.marker.mark_anon_var(lvl, term_loc, &mut target);
+                        target.push(Target::to_pstr(lvl, string, cell.get(), false));
                     }
                 }
                 TermRef::Var(lvl @ Level::Shallow, cell, ref var) if var.as_str() == "!" => {
@@ -265,14 +275,13 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                         }
                     }
 
-                    self.marker
-                        .mark_var(var.clone(), lvl, cell, term_loc, &mut target);
+                    self.marker.mark_var(var.clone(), lvl, cell, term_loc, &mut target);
                 }
                 TermRef::Var(lvl @ Level::Shallow, cell, var) => {
-                    self.marker
-                        .mark_var(var.clone(), lvl, cell, term_loc, &mut target)
+                    self.marker.mark_var(var.clone(), lvl, cell, term_loc, &mut target);
+                }
+                _ => {
                 }
-                _ => {}
             };
         }
 
@@ -281,11 +290,11 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
 
     fn collect_var_data(&mut self, mut iter: ChunkedIterator<'a>) -> ConjunctInfo<'a> {
         let mut vs = VariableFixtures::new();
-        
+
         while let Some((chunk_num, lt_arity, chunked_terms)) = iter.next() {
             for (i, chunked_term) in chunked_terms.iter().enumerate() {
                 let term_loc = match chunked_term {
-                    &ChunkedTerm::HeadClause(..) =>                       
+                    &ChunkedTerm::HeadClause(..) =>
                         GenContext::Head,
                     &ChunkedTerm::BodyTerm(_) => {
                         if i < chunked_terms.len() - 1 {
@@ -434,18 +443,6 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                     code.push(fail!());
                 }
             },
-            &InlinedClauseType::IsString(..) => match terms[0].as_ref() {
-                &Term::Constant(_, Constant::String(_)) => {
-                    code.push(succeed!());
-                }
-                &Term::Var(ref vr, ref name) => {
-                    let r = self.mark_non_callable(name.clone(), 1, term_loc, vr, code);
-                    code.push(is_string!(r));
-                }
-                _ => {
-                    code.push(fail!());
-                }
-            },
             &InlinedClauseType::IsNonVar(..) => match terms[0].as_ref() {
                 &Term::AnonVar => {
                     code.push(fail!());
@@ -459,8 +456,8 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                 }
             },
             &InlinedClauseType::IsInteger(..) => match terms[0].as_ref() {
-                &Term::Constant(_, Constant::CharCode(_))
-                | &Term::Constant(_, Constant::Integer(_)) => {
+                &Term::Constant(_, Constant::Integer(_)) |
+                &Term::Constant(_, Constant::Fixnum(_)) => {
                     code.push(succeed!());
                 }
                 &Term::Var(ref vr, ref name) => {
@@ -483,13 +480,6 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                     code.push(is_var!(r));
                 }
             },
-            &InlinedClauseType::IsPartialString(..) => match terms[0].as_ref() {
-                &Term::Var(ref vr, ref name) => {
-                    let r = self.mark_non_callable(name.clone(), 1, term_loc, vr, code);
-                    code.push(is_partial_string!(r));
-                }
-                _ => code.push(fail!()),
-            },
         }
 
         Ok(())
@@ -532,7 +522,8 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
                     code.push(is_call!(temp_v!(1), at.unwrap_or(interm!(1))))
                 }
             }
-            &Term::Constant(_, ref c @ Constant::Integer(_)) => {
+            &Term::Constant(_, ref c @ Constant::Integer(_)) |
+            &Term::Constant(_, ref c @ Constant::Fixnum(_)) => {
                 code.push(Line::Query(put_constant!(
                     Level::Shallow,
                     c.clone(),
@@ -694,6 +685,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
             head: (_, ref args, ref p1),
             ref clauses,
         } = rule;
+
         let mut code = Vec::new();
 
         self.marker.reset_at_head(args);
@@ -715,39 +707,31 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
         let iter = ChunkedIterator::from_rule_body(p1, clauses);
         self.compile_seq(iter, &conjunct_info, &mut code, false)?;
 
-        conjunct_info.mark_unsafe_vars(unsafe_var_marker, &self.marker, &mut code);        
+        conjunct_info.mark_unsafe_vars(unsafe_var_marker, &mut code);
 
         Self::compile_cleanup(&mut code, &conjunct_info, clauses.last().unwrap_or(p1));
         Ok(code)
     }
 
     fn mark_unsafe_fact_vars(&self, fact: &mut CompiledFact) -> UnsafeVarMarker {
-        let mut unsafe_vars = IndexMap::new();
-
-        for var_status in self.marker.bindings().values() {
-            unsafe_vars.insert(var_status.as_reg_type(), false);
-        }
+        let mut safe_vars = IndexSet::new();
 
         for fact_instr in fact.iter_mut() {
             match fact_instr {
-                &mut FactInstruction::UnifyValue(reg) => {
-                    if let Some(found) = unsafe_vars.get_mut(&reg) {
-                        if !*found {
-                            *found = true;
-                            *fact_instr = FactInstruction::UnifyLocalValue(reg);
-                        }
+                &mut FactInstruction::UnifyValue(r) => {
+                    if !safe_vars.contains(&r) {
+                        *fact_instr = FactInstruction::UnifyLocalValue(r);
+                        safe_vars.insert(r);
                     }
                 }
-                &mut FactInstruction::UnifyVariable(reg) => {
-                    if let Some(found) = unsafe_vars.get_mut(&reg) {
-                        *found = true;
-                    }
+                &mut FactInstruction::UnifyVariable(r) => {
+                    safe_vars.insert(r);
                 }
                 _ => {}
-            };
+            }
         }
 
-        UnsafeVarMarker { unsafe_vars }
+        UnsafeVarMarker::from_safe_vars(safe_vars)
     }
 
     pub fn compile_fact<'b: 'a>(&mut self, term: &'b Term) -> Code {
@@ -812,7 +796,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
         let iter = ChunkedIterator::from_term_sequence(query);
         self.compile_seq(iter, &conjunct_info, &mut code, true)?;
 
-        conjunct_info.mark_unsafe_vars(UnsafeVarMarker::new(), &self.marker, &mut code);
+        conjunct_info.mark_unsafe_vars(UnsafeVarMarker::new(), &mut code);
 
         if let Some(query_term) = query.last() {
             Self::compile_cleanup(&mut code, &conjunct_info, query_term);
@@ -867,7 +851,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
         clauses: &'b [PredicateClause],
     ) -> Result<Code, ParserError> {
         let mut code_body = Vec::new();
-        let mut code_offsets = CodeOffsets::new(self.flags);
+        let mut code_offsets = CodeOffsets::new();
 
         let num_clauses = clauses.len();
 

src/prolog/examples/least_time.pl

@@ -0,0 +1,64 @@
+/*  least_time.pl
+ *
+ *  By Mark Thom, 2020
+ *
+ *  find_min_time/2 solves a problem sometimes posed in the first round
+ *  of Google interviews: given a time of day in 24 H format, what is the
+ *  lexicographically least permutation of the time that is itself a
+ *  valid time in 24 H format?
+ *
+ *  Full generality is achieved using the reif library.
+ */
+
+:- module(least_time, [find_min_time/2,
+		       write_time_nl/1]).
+
+
+:- use_module(library(dcgs)).
+:- use_module(library(format)).
+:- use_module(library(reif)).
+
+
+permutation([], []).
+permutation([X|Xs], Ys) :-
+    permutation(Xs, Yss),
+    select(X, Ys, Yss).
+
+
+valid_time([H1,H2,M1,M2], T) :-
+    memberd_t(H1, [0,1,2], TH1),
+    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]) ->       
+       (  H1 =:= 2 ->
+	  (  H2 =< 3 ->
+	     T = true
+	  ;  T = false
+	  )
+       ;  T = true
+       )
+    ;  T = false
+    ).
+
+
+permuted_times(Time, PermutedTimes) :-
+    setof(P, permutation(Time, P), PermutedTimes0),
+    tfilter(valid_time, PermutedTimes0, 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)
+    ).
+
+
+write_time_nl(Time) :-
+    format("\"~w~w:~w~w\"~n", Time).

src/prolog/fixtures.rs

@@ -1,6 +1,5 @@
 use prolog_parser::ast::*;
 
-use crate::prolog::allocator::*;
 use crate::prolog::forms::*;
 use crate::prolog::instructions::*;
 use crate::prolog::iterators::*;
@@ -91,7 +90,7 @@ impl<'a> VariableFixtures<'a> {
             perm_vars: IndexMap::new(),
             last_chunk_temp_vars: IndexSet::new()
         }
-                          
+
     }
 
     pub fn insert(&mut self, var: Rc<Var>, vs: VariableFixture<'a>) {
@@ -250,67 +249,67 @@ impl<'a> VariableFixtures<'a> {
 }
 
 pub struct UnsafeVarMarker {
-    pub unsafe_vars: IndexMap<RegType, bool>,
+    pub unsafe_vars: IndexMap<RegType, usize>,
+    pub safe_vars: IndexSet<RegType>,
 }
 
 impl UnsafeVarMarker {
     pub fn new() -> Self {
         UnsafeVarMarker {
             unsafe_vars: IndexMap::new(),
+            safe_vars: IndexSet::new()
         }
     }
 
-    pub fn record_unsafe_vars<'a, Alloc: Allocator<'a>>(
-        &mut self,
-        fixtures: &VariableFixtures,
-        marker: &Alloc
-    ) {
-        for &(_, ref cb) in fixtures.values() {           
-            if let Some(index) = cb.first() {
-                if !self.unsafe_vars.contains_key(&index.get().norm()) {
-                    self.unsafe_vars.insert(index.get().norm(), false);
-                }
-            }
-        }
-
-        for var in fixtures.last_chunk_temp_vars.iter().cloned() {
-            let r = marker.get(var);
-            self.unsafe_vars.insert(r, false);
+    pub fn from_safe_vars(safe_vars: IndexSet<RegType>) -> Self {
+        UnsafeVarMarker {
+            unsafe_vars: IndexMap::new(),
+            safe_vars
         }
     }
 
-    pub fn mark_safe_vars(&mut self, query_instr: &QueryInstruction) {
+    pub fn mark_safe_vars(&mut self, query_instr: &QueryInstruction) -> bool {
         match query_instr {
-            QueryInstruction::PutVariable(RegType::Temp(r), _) => {
-                if let Some(found) = self.unsafe_vars.get_mut(&RegType::Temp(*r)) {
-                    *found = true;
-                }
+            &QueryInstruction::PutVariable(r @ RegType::Temp(_), _)
+          | &QueryInstruction::SetVariable(r) =>  {
+                self.safe_vars.insert(r);
+                true
             }
-            QueryInstruction::SetVariable(reg) => {
-                if let Some(found) = self.unsafe_vars.get_mut(reg) {
-                    *found = true;
-                }
+            _ => {
+                false
+            }
+        }
+    }
+
+    pub fn mark_phase(&mut self, query_instr: &QueryInstruction, phase: usize) {
+        match query_instr {
+            &QueryInstruction::PutValue(r @ RegType::Perm(_), _)
+          | &QueryInstruction::SetValue(r) => {
+                let p = self.unsafe_vars.entry(r).or_insert(0);
+                *p = phase;
             }
             _ => {}
         }
     }
 
-    pub fn mark_unsafe_vars(&mut self, query_instr: &mut QueryInstruction) {
+    pub fn mark_unsafe_vars(&mut self, query_instr: &mut QueryInstruction, phase: usize) {
         match query_instr {
             &mut QueryInstruction::PutValue(RegType::Perm(i), arg) => {
-                if let Some(found) = self.unsafe_vars.get_mut(&RegType::Perm(i)) {
-                    if !*found {
-                        *found = true;
+                if let Some(p) = self.unsafe_vars.swap_remove(&RegType::Perm(i)) {
+                    if p == phase {
                         *query_instr = QueryInstruction::PutUnsafeValue(i, arg);
+                        self.safe_vars.insert(RegType::Perm(i));
+                    } else {
+                        self.unsafe_vars.insert(RegType::Perm(i), p);
                     }
                 }
             }
-            &mut QueryInstruction::SetValue(reg) => {
-                if let Some(found) = self.unsafe_vars.get_mut(&reg) {
-                    if !*found {
-                        *found = true;
-                        *query_instr = QueryInstruction::SetLocalValue(reg);
-                    }
+            &mut QueryInstruction::SetValue(r) => {
+                if !self.safe_vars.contains(&r) {
+                    *query_instr = QueryInstruction::SetLocalValue(r);
+
+                    self.safe_vars.insert(r);
+                    self.unsafe_vars.remove(&r);
                 }
             }
             _ => {}

src/prolog/forms.rs

@@ -12,6 +12,8 @@ use indexmap::IndexMap;
 
 use std::cell::Cell;
 use std::collections::VecDeque;
+use std::convert::TryFrom;
+use std::path::PathBuf;
 use std::rc::Rc;
 
 pub type PredicateKey = (ClauseName, usize); // name, arity.
@@ -30,26 +32,6 @@ pub enum TopLevel {
 }
 
 impl TopLevel {
-    pub fn name(&self) -> Option<ClauseName> {
-        match self {
-            &TopLevel::Declaration(_) => None,
-            &TopLevel::Fact(ref term, ..) => term.name(),
-            &TopLevel::Predicate(ref clauses) => clauses.0.first().and_then(|ref term| term.name()),
-            &TopLevel::Query(_) => None,
-            &TopLevel::Rule(Rule { ref head, .. }, ..) => Some(head.0.clone()),
-        }
-    }
-
-    pub fn arity(&self) -> usize {
-        match self {
-            &TopLevel::Declaration(_) => 0,
-            &TopLevel::Fact(ref term, ..) => term.arity(),
-            &TopLevel::Predicate(ref clauses) => clauses.0.first().map(|t| t.arity()).unwrap_or(0),
-            &TopLevel::Query(_) => 0,
-            &TopLevel::Rule(Rule { ref head, .. }, ..) => head.1.len(),
-        }
-    }
-
     pub fn is_end_of_file_atom(&self) -> bool {
         match self {
             &TopLevel::Fact(Term::Constant(_, Constant::Atom(ref name, _)), ..) => {
@@ -132,6 +114,216 @@ impl Predicate {
     }
 }
 
+#[derive(Clone)]
+pub enum ListingSource {
+    File(ClauseName, PathBuf), // filename, path
+    User,
+}
+
+impl ListingSource {
+    pub fn from_file_and_path(filename: ClauseName, path_buf: PathBuf) -> Self {
+        ListingSource::File(filename, path_buf)
+    }
+
+    pub fn name(&self) -> ClauseName {
+        match self {
+            ListingSource::File(ref filename, _) => filename.clone(),
+            ListingSource::User => clause_name!("[user]")
+        }
+    }
+
+    pub fn path(&self) -> PathBuf {
+        match self {
+            ListingSource::File(_, ref path) => path.clone(),
+            ListingSource::User => std::env::current_dir().unwrap(),
+        }
+    }
+}
+
+fn resolved_term_and_module(term: &Term) -> Option<(ClauseName, ClauseName)>
+{
+    match term {
+        Term::Clause(_, ref name, ref terms, _) => {
+            if name.as_str() == ":" && terms.len() == 2 {
+                let module_name = match terms[0].as_ref() {
+                    &Term::Constant(_, Constant::Atom(ref module_name, _)) => {
+                        module_name.clone()
+                    }
+                    _ => {
+                        return Some((name.owning_module(), name.clone()));
+                    }
+                };
+
+                match terms[1].as_ref() {
+                    Term::Clause(_, ref name, ..)
+                  | Term::Constant(_, Constant::Atom(ref name, ..)) => {
+                        return Some((module_name, name.clone()));
+                    }
+                    _ => {
+                    }
+                }
+
+                Some((name.owning_module(), name.clone()))
+            } else {
+                Some((name.owning_module(), name.clone()))
+            }
+        }
+        Term::Constant(_, Constant::Atom(ref name, _)) => {
+            Some((name.owning_module(), name.clone()))
+        }
+        _ => {
+            None
+        }
+    }
+}
+
+fn resolved_term_arity(term: &Term) -> usize
+{
+    match term {
+        Term::Clause(_, ref name, ref terms, _) => {
+            if name.as_str() == ":" && terms.len() == 2 {
+                match terms[0].as_ref() {
+                    &Term::Constant(_, Constant::Atom(..)) => {
+                    }
+                    _ => {
+                        return 2;
+                    }
+                }
+
+                match terms[1].as_ref() {
+                    Term::Clause(_, _, ref terms, _) => {
+                        terms.len()
+                    }
+                    Term::Constant(_, Constant::Atom(..)) => {
+                        0
+                    }
+                    _ => {
+                        2
+                    }
+                }
+            } else {
+                terms.len()
+            }
+        }
+        _ => {
+            0
+        }
+    }
+}
+
+pub trait ClauseConsistency {
+    fn is_consistent(&self, clauses: &Vec<PredicateClause>) -> bool {
+        match clauses.first() {
+            Some(ref cl) => {
+                self.name_and_module() == cl.name_and_module() && self.arity() == cl.arity()
+            }
+            None => {
+                true
+            }
+        }
+    }
+
+    fn name_and_module(&self) -> Option<(ClauseName, ClauseName)>;
+    fn arity(&self) -> usize;
+}
+
+/* Of course '$current_module$' isn't the name of the current
+ * module. It'll do if no module is explicitly specified through
+ * (:)/2.
+ */
+impl ClauseConsistency for Term {
+    fn name_and_module(&self) -> Option<(ClauseName, ClauseName)>
+    {
+        match self {
+            Term::Clause(_, ref name, ref terms, _) =>
+                match name.as_str() {
+                    ":-" => {
+                        match terms.len() {
+                            1 => None, // a declaration.
+                            2 => resolved_term_and_module(&terms[0]),
+                            _ => Some((name.owning_module(), clause_name!(":-"))),
+                        }
+                    }
+                    _ => {
+                        resolved_term_and_module(self)
+                    }
+                },
+            Term::Constant(_, Constant::Atom(ref name, _)) => {
+                Some((name.owning_module(), name.clone()))
+            }
+            _ => {
+                None
+            }
+        }
+    }
+
+    fn arity(&self) -> usize {
+        match self {
+            Term::Clause(_, ref name, ref terms, _) =>
+                match name.as_str() {
+                    ":-" => {
+                        match terms.len() {
+                            1 => 0,
+                            2 => resolved_term_arity(&terms[0]),
+                            _ => terms.len(),
+                        }
+                    }
+                    _ => {
+                        resolved_term_arity(self)
+                    }
+                },
+            _ => {
+                0
+            }
+        }
+    }
+}
+
+impl ClauseConsistency for Rule {
+    fn name_and_module(&self) -> Option<(ClauseName, ClauseName)> {
+        Some((self.head.0.owning_module(), self.head.0.clone()))
+    }
+
+    fn arity(&self) -> usize {
+        self.head.1.len()
+    }
+}
+
+impl ClauseConsistency for PredicateClause {
+    fn name_and_module(&self) -> Option<(ClauseName, ClauseName)> {
+        match self {
+            &PredicateClause::Fact(ref term, ..) => {
+                term.name_and_module()
+                    .map(|(_, name)| (name.owning_module(), name))
+            }
+            &PredicateClause::Rule(ref rule, ..) => {
+                rule.name_and_module()
+            }
+        }
+    }
+
+    fn arity(&self) -> usize {
+        match self {
+            &PredicateClause::Fact(ref term, ..) => {
+                term.arity()
+            }
+            &PredicateClause::Rule(ref rule, ..) => {
+                rule.arity()
+            }
+        }
+    }
+}
+
+impl ClauseConsistency for Predicate {
+    fn name_and_module(&self) -> Option<(ClauseName, ClauseName)> {
+        self.0.first().and_then(|clause| clause.name_and_module())
+    }
+
+    fn arity(&self) -> usize {
+        self.0.first().map(|clause| clause.arity()).unwrap_or(0)
+    }
+}
+
 pub type CompiledResult = (Predicate, VecDeque<TopLevel>);
 
 #[derive(Clone)]
@@ -150,8 +342,24 @@ impl PredicateClause {
 
     pub fn arity(&self) -> usize {
         match self {
-            &PredicateClause::Fact(ref term, ..) => term.arity(),
-            &PredicateClause::Rule(ref rule, ..) => rule.head.1.len(),
+            &PredicateClause::Fact(ref term, ..) => {
+                term.arity()
+            }
+            &PredicateClause::Rule(ref rule, ..) => {
+                if rule.head.0.as_str() == ":" && rule.head.1.len() == 2 {
+                    match (rule.head.1)[0].as_ref() {
+                        &Term::Constant(_, Constant::Atom(..)) => {
+                        }
+                        _ => {
+                            return 2;
+                        }
+                    }
+
+                    (rule.head.1)[1].arity()
+                } else {
+                    rule.head.1.len()
+                }
+            }
         }
     }
 
@@ -169,6 +377,27 @@ pub enum ModuleSource {
     File(ClauseName),
 }
 
+impl ModuleSource {
+    pub fn as_functor_stub(&self) -> MachineStub {
+        match self {
+            ModuleSource::Library(ref name) => {
+                functor!("library", [clause_name(name.clone())])
+            }
+            ModuleSource::File(ref name) => {
+                functor!(clause_name(name.clone()))
+            }
+        }
+    }
+}
+
+pub type ScopedPredicateKey = (ClauseName, PredicateKey); // module name, predicate indicator.
+
+#[derive(Clone)]
+pub enum MultiFileIndicator {
+    LocalScoped(ClauseName, usize), // name, arity
+    ModuleScoped(ScopedPredicateKey),
+}
+
 #[derive(Clone)]
 pub enum Declaration {
     Dynamic(ClauseName, usize), // name, arity
@@ -176,10 +405,12 @@ pub enum Declaration {
     Hook(CompileTimeHook, PredicateClause, VecDeque<TopLevel>),
     ModuleInitialization(Vec<QueryTerm>, VecDeque<TopLevel>), // goal
     Module(ModuleDecl),
+    MultiFile(MultiFileIndicator),
     NonCountedBacktracking(ClauseName, usize), // name, arity
     Op(OpDecl),
+    SetPrologFlag(DoubleQuotes),
     UseModule(ModuleSource),
-    UseQualifiedModule(ModuleSource, Vec<PredicateKey>),
+    UseQualifiedModule(ModuleSource, Vec<ModuleExport>),
 }
 
 impl Declaration {
@@ -216,15 +447,20 @@ impl OpDecl {
         self.insert_into_op_dir(clause_name!(""), op_dir, 0);
     }
 
-    fn insert_into_op_dir(&self, module: ClauseName, op_dir: &mut OpDir, prec: usize) {
-        let (spec, name) = (self.1, self.2.clone());
-
-        let fixity = match spec {
+    #[inline]
+    pub fn fixity(&self) -> Fixity {
+        match self.1 {
             XFY | XFX | YFX => Fixity::In,
             XF | YF => Fixity::Post,
             FX | FY => Fixity::Pre,
-            _ => return,
-        };
+            _ => unreachable!()
+        }
+    }
+
+    pub fn insert_into_op_dir(&self, module: ClauseName, op_dir: &mut OpDir, prec: usize) {
+        let (spec, name) = (self.1, self.2.clone());
+
+        let fixity = self.fixity();
 
         match op_dir.get(&(name.clone(), fixity)) {
             Some(cell) => {
@@ -281,11 +517,11 @@ pub fn fetch_op_spec(
     op_dir: &OpDir,
 ) -> Option<SharedOpDesc> {
     if let Some(ref op_desc) = &spec {
-        if op_desc.arity() != arity {            
+        if op_desc.arity() != arity {
             /* it's possible to extend operator functors with
              * additional terms. When that happens,
              * void the op_spec by returning None. */
-            return None; 
+            return None;
         }
     }
 
@@ -322,10 +558,16 @@ pub fn fetch_op_spec(
 
 pub type ModuleDir = IndexMap<ClauseName, Module>;
 
+#[derive(Clone, PartialEq)]
+pub enum ModuleExport {
+    OpDecl(OpDecl),
+    PredicateKey(PredicateKey),
+}
+
 #[derive(Clone)]
 pub struct ModuleDecl {
     pub name: ClauseName,
-    pub exports: Vec<PredicateKey>,
+    pub exports: Vec<ModuleExport>,
 }
 
 pub struct Module {
@@ -333,18 +575,45 @@ pub struct Module {
     pub module_decl: ModuleDecl,
     pub code_dir: CodeDir,
     pub op_dir: OpDir,
+    pub term_dir: TermDir, // this contains multifile predicates.
     pub term_expansions: (Predicate, VecDeque<TopLevel>),
     pub goal_expansions: (Predicate, VecDeque<TopLevel>),
     pub user_term_expansions: (Predicate, VecDeque<TopLevel>), // term expansions inherited from the user scope.
     pub user_goal_expansions: (Predicate, VecDeque<TopLevel>), // same for goal_expansions.
+    pub local_term_expansions: (Predicate, VecDeque<TopLevel>), // expansions local to the module.
+    pub local_goal_expansions: (Predicate, VecDeque<TopLevel>),
     pub inserted_expansions: bool, // has the module been successfully inserted into toplevel??
+    pub is_impromptu_module: bool,
+    pub listing_src: ListingSource,
  }
 
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone)]
 pub enum Number {
     Float(OrderedFloat<f64>),
-    Integer(Integer),
-    Rational(Rational),
+    Integer(Rc<Integer>),
+    Rational(Rc<Rational>),
+    Fixnum(isize),
+}
+
+impl From<Integer> for Number {
+    #[inline]
+    fn from(n: Integer) -> Self {
+        Number::Integer(Rc::new(n))
+    }
+}
+
+impl From<Rational> for Number {
+    #[inline]
+    fn from(n: Rational) -> Self {
+        Number::Rational(Rc::new(n))
+    }
+}
+
+impl From<isize> for Number {
+    #[inline]
+    fn from(n: isize) -> Self {
+        Number::Fixnum(n)
+    }
 }
 
 impl Default for Number {
@@ -353,48 +622,89 @@ impl Default for Number {
     }
 }
 
-impl Number {
-    pub fn to_constant(self) -> Constant {
+impl Into<Constant> for Number {
+    #[inline]
+    fn into(self) -> Constant {
         match self {
+            Number::Fixnum(n) => Constant::Fixnum(n),
             Number::Integer(n) => Constant::Integer(n),
             Number::Float(f) => Constant::Float(f),
             Number::Rational(r) => Constant::Rational(r),
         }
     }
+}
+
+impl Into<HeapCellValue> for Number {
+    #[inline]
+    fn into(self) -> HeapCellValue {
+        match self {
+            Number::Fixnum(n) => HeapCellValue::Addr(Addr::Fixnum(n)),
+            Number::Integer(n) => HeapCellValue::Integer(n),
+            Number::Float(f) => HeapCellValue::Addr(Addr::Float(f)),
+            Number::Rational(r) => HeapCellValue::Rational(r),
+        }
+    }
+}
+
+
+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 {
-            &Number::Integer(ref n) => n > &0,
+            &Number::Fixnum(n) => n > 0,
+            &Number::Integer(ref n) => &**n > &0,
             &Number::Float(OrderedFloat(f)) => f.is_sign_positive(),
-            &Number::Rational(ref r) => r > &0,
+            &Number::Rational(ref r) => &**r > &0,
         }
     }
 
     #[inline]
     pub fn is_negative(&self) -> bool {
         match self {
-            &Number::Integer(ref n) => n < &0,
+            &Number::Fixnum(n) => n < 0,
+            &Number::Integer(ref n) => &**n < &0,
             &Number::Float(OrderedFloat(f)) => f.is_sign_negative(),
-            &Number::Rational(ref r) => r < &0,
+            &Number::Rational(ref r) => &**r < &0,
         }
     }
 
     #[inline]
     pub fn is_zero(&self) -> bool {
         match self {
-            &Number::Integer(ref n) => n == &0,
+            &Number::Fixnum(n) => n == 0,
+            &Number::Integer(ref n) => &**n == &0,
             &Number::Float(f) => f == OrderedFloat(0f64),
-            &Number::Rational(ref r) => r == &0,
+            &Number::Rational(ref r) => &**r == &0,
         }
     }
 
     #[inline]
     pub fn abs(self) -> Self {
         match self {
-            Number::Integer(n) => Number::Integer(n.abs()),
+            Number::Fixnum(n) =>
+                if let Some(n) = n.checked_abs() {
+                    Number::from(n)
+                } else {
+                    Number::from(Integer::from(n).abs())
+                }
+            Number::Integer(n) => Number::from(Integer::from(n.abs_ref())),
             Number::Float(f) => Number::Float(OrderedFloat(f.abs())),
-            Number::Rational(r) => Number::Rational(r.abs()),
+            Number::Rational(r) => Number::from(Rational::from(r.abs_ref())),
         }
     }
 }

src/prolog/heap_iter.rs

@@ -1,5 +1,3 @@
-use prolog_parser::ast::*;
-
 use crate::prolog::machine::machine_indices::*;
 use crate::prolog::machine::machine_state::*;
 
@@ -22,6 +20,7 @@ impl<'a> HCPreOrderIterator<'a> {
         }
     }
 
+    #[inline]
     pub fn machine_st(&self) -> &MachineState {
         &self.machine_st
     }
@@ -29,13 +28,25 @@ impl<'a> HCPreOrderIterator<'a> {
     fn follow_heap(&mut self, h: usize) -> Addr {
         match &self.machine_st.heap[h] {
             &HeapCellValue::NamedStr(arity, _, _) => {
-                for idx in (1..arity + 1).rev() {
+                for idx in (1 .. arity + 1).rev() {
                     self.state_stack.push(Addr::HeapCell(h + idx));
                 }
 
-                Addr::HeapCell(h)
+                Addr::Str(h)
+            }
+            &HeapCellValue::Addr(a) => {
+                self.follow(a)
+            }
+            HeapCellValue::PartialString(..) => {
+                self.follow(Addr::PStrLocation(h, 0))
+            }
+            HeapCellValue::Atom(..) | HeapCellValue::DBRef(_)
+          | HeapCellValue::Integer(_) | HeapCellValue::Rational(_) => {
+                Addr::Con(h)
+            }
+            HeapCellValue::Stream(_) => {
+                Addr::Stream(h)
             }
-            &HeapCellValue::Addr(ref a) => self.follow(a.clone()),
         }
     }
 
@@ -46,79 +57,90 @@ impl<'a> HCPreOrderIterator<'a> {
         let da = self.machine_st.store(self.machine_st.deref(addr));
 
         match da {
-            Addr::Con(Constant::String(ref s)) => {
-                match self.machine_st.machine_flags().double_quotes {
-                    DoubleQuotes::Chars => {
-                        if let Some(c) = s.head() {
-                            let tail = s.tail();
-
-                            self.state_stack.push(Addr::Con(Constant::String(tail)));
-                            self.state_stack.push(Addr::Con(Constant::Char(c)));
-                        }
-                    }
-                    DoubleQuotes::Codes => {
-                        if let Some(c) = s.head() {
-                            let tail = s.tail();
-
-                            self.state_stack.push(Addr::Con(Constant::String(tail)));
-                            self.state_stack
-                                .push(Addr::Con(Constant::CharCode(c as u8)));
-                        }
-                    }
-                    _ => {}
-                }
-
-                Addr::Con(Constant::String(s.clone()))
-            }
-            Addr::Con(_) | Addr::DBRef(_) => da,
             Addr::Lis(a) => {
                 self.state_stack.push(Addr::HeapCell(a + 1));
                 self.state_stack.push(Addr::HeapCell(a));
 
                 da
             }
-            Addr::AttrVar(_) | Addr::HeapCell(_) | Addr::StackCell(_, _) => da,
-            Addr::Str(s) => self.follow_heap(s), // record terms of structure.
+            Addr::PStrLocation(h, n) => {
+                if let &HeapCellValue::PartialString(ref pstr, has_tail) = &self.machine_st.heap[h] {
+                    if let Some(c) = pstr.range_from(n ..).next() {
+                        if !pstr.at_end(n + c.len_utf8()) {
+                            self.state_stack.push(Addr::PStrLocation(h, n + c.len_utf8()));
+                        } else if has_tail {
+                            self.state_stack.push(Addr::HeapCell(h + 1));
+                        } else {
+                            self.state_stack.push(Addr::EmptyList);
+                        }
+
+                        self.state_stack.push(Addr::Char(c));
+                    } else if has_tail {
+                        return self.follow(Addr::HeapCell(h + 1));
+                    }
+                } else {
+                    unreachable!()
+                }
+
+                Addr::PStrLocation(h, n)
+            }
+            Addr::Str(s) => {
+                self.follow_heap(s) // record terms of structure.
+            }
+            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));
+
+                            Addr::PStrLocation(h, 0)
+                        } else if has_tail {
+                            self.follow(Addr::HeapCell(h + 1))
+                        } else {
+                            Addr::EmptyList
+                        };
+                    }
+                }
+
+                Addr::Con(h)
+            }
+            da => {
+                da
+            }
         }
     }
 }
 
 impl<'a> Iterator for HCPreOrderIterator<'a> {
-    type Item = HeapCellValue;
+    type Item = Addr;
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.state_stack.pop().map(|a| match self.follow(a) {
-            Addr::HeapCell(h) => self.machine_st.heap[h].clone(),
-            Addr::StackCell(fr, sc) => {
-                HeapCellValue::Addr(self.machine_st.and_stack[fr][sc].clone())
-            }
-            da => HeapCellValue::Addr(da),
-        })
+        self.state_stack.pop().map(|a| self.follow(a))
     }
 }
 
 pub trait MutStackHCIterator
-where
-    Self: Iterator<Item = HeapCellValue>,
+where Self: Iterator<Item = Addr>
 {
     fn stack(&mut self) -> &mut Vec<Addr>;
 }
 
-pub struct HCPostOrderIterator<HCIter> {
-    base_iter: HCIter,
-    parent_stack: Vec<(usize, HeapCellValue)>, // number of children, parent node.
+pub struct HCPostOrderIterator<'a> {
+    base_iter: HCPreOrderIterator<'a>,
+    parent_stack: Vec<(usize, Addr)>, // number of children, parent node.
 }
 
-impl<HCIter> Deref for HCPostOrderIterator<HCIter> {
-    type Target = HCIter;
+impl<'a> Deref for HCPostOrderIterator<'a> {
+    type Target = HCPreOrderIterator<'a>;
 
     fn deref(&self) -> &Self::Target {
         &self.base_iter
     }
 }
 
-impl<HCIter: Iterator<Item = HeapCellValue>> HCPostOrderIterator<HCIter> {
-    pub fn new(base_iter: HCIter) -> Self {
+impl<'a> HCPostOrderIterator<'a> {
+    pub fn new(base_iter: HCPreOrderIterator<'a>) -> Self {
         HCPostOrderIterator {
             base_iter,
             parent_stack: vec![],
@@ -126,8 +148,8 @@ impl<HCIter: Iterator<Item = HeapCellValue>> HCPostOrderIterator<HCIter> {
     }
 }
 
-impl<HCIter: Iterator<Item = HeapCellValue>> Iterator for HCPostOrderIterator<HCIter> {
-    type Item = HeapCellValue;
+impl<'a> Iterator for HCPostOrderIterator<'a> {
+    type Item = Addr;
 
     fn next(&mut self) -> Option<Self::Item> {
         loop {
@@ -140,15 +162,30 @@ impl<HCIter: Iterator<Item = HeapCellValue>> Iterator for HCPostOrderIterator<HC
             }
 
             if let Some(item) = self.base_iter.next() {
-                match item {
-                    HeapCellValue::NamedStr(arity, name, fix) => self
-                        .parent_stack
-                        .push((arity, HeapCellValue::NamedStr(arity, name, fix))),
-                    HeapCellValue::Addr(Addr::Lis(a)) => self
-                        .parent_stack
-                        .push((2, HeapCellValue::Addr(Addr::Lis(a)))),
-                    child_node => {
-                        return Some(child_node);
+                match self.base_iter.machine_st.heap.index_addr(&item).as_ref() {
+                    &HeapCellValue::NamedStr(arity, ..) => {
+                        self.parent_stack.push((arity, item));
+                    }
+                    &HeapCellValue::Addr(Addr::Lis(a)) => {
+                        self.parent_stack.push((2, Addr::Lis(a)));
+                    }
+                    &HeapCellValue::Addr(Addr::PStrLocation(h, n)) => {
+                        match &self.machine_st.heap[h] {
+                            &HeapCellValue::PartialString(ref pstr, _) => {
+                                let c = pstr.range_from(n ..).next().unwrap();
+                                let next_n = n + c.len_utf8();
+
+                                if !pstr.at_end(next_n) {
+                                    self.parent_stack.push((2, Addr::PStrLocation(h, next_n)));
+                                }
+                            }
+                            _ => {
+                                unreachable!()
+                            }
+                        }
+                    }
+                    _ => {
+                        return Some(item);
                     }
                 }
             } else {
@@ -158,21 +195,16 @@ impl<HCIter: Iterator<Item = HeapCellValue>> Iterator for HCPostOrderIterator<HC
     }
 }
 
-pub type HCProperPostOrderIterator<'a> = HCPostOrderIterator<HCPreOrderIterator<'a>>;
-
 impl MachineState {
     pub fn pre_order_iter<'a>(&'a self, a: Addr) -> HCPreOrderIterator<'a> {
         HCPreOrderIterator::new(self, a)
     }
 
-    pub fn post_order_iter<'a>(&'a self, a: Addr) -> HCProperPostOrderIterator<'a> {
+    pub fn post_order_iter<'a>(&'a self, a: Addr) -> HCPostOrderIterator<'a> {
         HCPostOrderIterator::new(HCPreOrderIterator::new(self, a))
     }
 
-    pub fn acyclic_pre_order_iter<'a>(
-        &'a self,
-        a: Addr,
-    ) -> HCAcyclicIterator<HCPreOrderIterator<'a>> {
+    pub fn acyclic_pre_order_iter<'a>(&'a self, a: Addr,) -> HCAcyclicIterator<'a> {
         HCAcyclicIterator::new(HCPreOrderIterator::new(self, a))
     }
 
@@ -180,7 +212,7 @@ impl MachineState {
         &'a self,
         a1: Addr,
         a2: Addr,
-    ) -> HCZippedAcyclicIterator<HCPreOrderIterator<'a>> {
+    ) -> HCZippedAcyclicIterator<'a> {
         HCZippedAcyclicIterator::new(
             HCPreOrderIterator::new(self, a1),
             HCPreOrderIterator::new(self, a2),
@@ -194,13 +226,13 @@ impl<'a> MutStackHCIterator for HCPreOrderIterator<'a> {
     }
 }
 
-pub struct HCAcyclicIterator<HCIter> {
-    iter: HCIter,
+pub struct HCAcyclicIterator<'a> {
+    iter: HCPreOrderIterator<'a>,
     seen: IndexSet<Addr>,
 }
 
-impl<HCIter: MutStackHCIterator> HCAcyclicIterator<HCIter> {
-    pub fn new(iter: HCIter) -> Self {
+impl<'a> HCAcyclicIterator<'a> {
+    pub fn new(iter: HCPreOrderIterator<'a>) -> Self {
         HCAcyclicIterator {
             iter,
             seen: IndexSet::new(),
@@ -208,19 +240,17 @@ impl<HCIter: MutStackHCIterator> HCAcyclicIterator<HCIter> {
     }
 }
 
-impl<HCIter> Deref for HCAcyclicIterator<HCIter> {
-    type Target = HCIter;
+impl<'a> Deref for HCAcyclicIterator<'a> {
+    type Target = HCPreOrderIterator<'a>;
 
     fn deref(&self) -> &Self::Target {
         &self.iter
     }
 }
 
-impl<HCIter> Iterator for HCAcyclicIterator<HCIter>
-where
-    HCIter: Iterator<Item = HeapCellValue> + MutStackHCIterator,
+impl<'a> Iterator for HCAcyclicIterator<'a>
 {
-    type Item = HeapCellValue;
+    type Item = Addr;
 
     fn next(&mut self) -> Option<Self::Item> {
         while let Some(addr) = self.iter.stack().pop() {
@@ -236,15 +266,15 @@ where
     }
 }
 
-pub struct HCZippedAcyclicIterator<HCIter> {
-    i1: HCIter,
-    i2: HCIter,
+pub struct HCZippedAcyclicIterator<'a> {
+    i1: HCPreOrderIterator<'a>,
+    i2: HCPreOrderIterator<'a>,
     seen: IndexSet<(Addr, Addr)>,
     pub first_to_expire: Ordering,
 }
 
-impl<HCIter: MutStackHCIterator> HCZippedAcyclicIterator<HCIter> {
-    pub fn new(i1: HCIter, i2: HCIter) -> Self {
+impl<'a> HCZippedAcyclicIterator<'a> {
+    pub fn new(i1: HCPreOrderIterator<'a>, i2: HCPreOrderIterator<'a>) -> Self {
         HCZippedAcyclicIterator {
             i1,
             i2,
@@ -254,11 +284,9 @@ impl<HCIter: MutStackHCIterator> HCZippedAcyclicIterator<HCIter> {
     }
 }
 
-impl<HCIter> Iterator for HCZippedAcyclicIterator<HCIter>
-where
-    HCIter: Iterator<Item = HeapCellValue> + MutStackHCIterator,
+impl<'a> Iterator for HCZippedAcyclicIterator<'a>
 {
-    type Item = (HeapCellValue, HeapCellValue);
+    type Item = (Addr, Addr);
 
     fn next(&mut self) -> Option<Self::Item> {
         while let (Some(a1), Some(a2)) = (self.i1.stack().pop(), self.i2.stack().pop()) {
@@ -281,7 +309,9 @@ where
                 self.first_to_expire = Ordering::Less;
                 None
             }
-            _ => None,
+            _ => {
+                None
+            }
         }
     }
 }

src/prolog/indexing.rs

@@ -1,11 +1,13 @@
 use prolog_parser::ast::*;
 
 use crate::prolog::instructions::*;
+use crate::prolog::rug::Integer;
 
 use indexmap::IndexMap;
 
 use std::collections::VecDeque;
 use std::hash::Hash;
+use std::rc::Rc;
 
 #[derive(Clone, Copy)]
 enum IntIndex {
@@ -15,16 +17,14 @@ enum IntIndex {
 }
 
 pub struct CodeOffsets {
-    flags: MachineFlags,
     pub constants: IndexMap<Constant, ThirdLevelIndex>,
     pub lists: ThirdLevelIndex,
     pub structures: IndexMap<(ClauseName, usize), ThirdLevelIndex>,
 }
 
 impl CodeOffsets {
-    pub fn new(flags: MachineFlags) -> Self {
+    pub fn new() -> Self {
         CodeOffsets {
-            flags,
             constants: IndexMap::new(),
             lists: Vec::new(),
             structures: IndexMap::new(),
@@ -50,6 +50,41 @@ impl CodeOffsets {
         }
     }
 
+    fn intercept_constant(&mut self, constant: &Constant, index: usize) {
+        match constant {
+            &Constant::Atom(ref name, _) 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));
+            }
+            &Constant::Fixnum(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));
+            }
+            &Constant::Integer(ref n) => {
+                if let Some(n) = n.to_isize() {
+                    let code = self.constants
+                        .entry(Constant::Fixnum(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));
+            }
+            _ => {
+            }
+        }
+    }
+
     pub fn index_term(&mut self, first_arg: &Term, index: usize) {
         match first_arg {
             &Term::Clause(_, ref name, ref terms, _) => {
@@ -65,21 +100,12 @@ impl CodeOffsets {
                 let is_initial_index = self.lists.is_empty();
                 self.lists.push(Self::add_index(is_initial_index, index));
             }
-            &Term::Constant(_, Constant::String(ref s))
-                if !self.flags.double_quotes.is_atom() && !s.is_empty() =>
-            {
-                // strings are lists in this case.
-                let is_initial_index = self.lists.is_empty();
-                self.lists.push(Self::add_index(is_initial_index, index));
-            }
-            &Term::Constant(_, Constant::String(ref s))
-                if !self.flags.double_quotes.is_atom() && s.is_expandable() =>
-            {
-                let is_initial_index = self.lists.is_empty();
-                self.lists.push(Self::add_index(is_initial_index, index));
-            }
             &Term::Constant(_, ref constant) => {
-                let code = self.constants.entry(constant.clone()).or_insert(Vec::new());
+                self.intercept_constant(constant, index);
+
+                let code = self.constants
+                    .entry(constant.clone())
+                    .or_insert(vec![]);
 
                 let is_initial_index = code.is_empty();
                 code.push(Self::add_index(is_initial_index, index));
@@ -232,12 +258,11 @@ impl CodeOffsets {
     fn switch_on_lst_offset_from(
         lst_loc: IntIndex,
         prelude_len: usize,
-        lst_offset: usize,
     ) -> usize {
         match lst_loc {
             IntIndex::External(o) => o + prelude_len + 1,
             IntIndex::Fail => 0,
-            IntIndex::Internal(_) => prelude_len - lst_offset + 1,
+            IntIndex::Internal(_) => 1, // this internal is always 0.
         }
     }
 
@@ -250,8 +275,6 @@ impl CodeOffsets {
         let mut prelude = VecDeque::new();
 
         let lst_loc = Self::switch_on_list(self.lists, &mut prelude);
-        let lst_offset = prelude.len();
-
         let str_loc = Self::switch_on_structure(self.structures, &mut prelude);
         let con_loc = Self::switch_on_constant(self.constants, &mut prelude);
 
@@ -259,18 +282,19 @@ impl CodeOffsets {
 
         for (index, line) in prelude.iter_mut().enumerate() {
             match line {
-                &mut Line::IndexedChoice(IndexedChoiceInstruction::Try(ref mut i))
-                | &mut Line::IndexedChoice(IndexedChoiceInstruction::Retry(ref mut i))
-                | &mut Line::IndexedChoice(IndexedChoiceInstruction::Trust(ref mut i)) => {
-                    *i += prelude_length - index
+                &mut Line::IndexedChoice(IndexedChoiceInstruction::Try(ref mut i)) |
+                &mut Line::IndexedChoice(IndexedChoiceInstruction::Retry(ref mut i)) |
+                &mut Line::IndexedChoice(IndexedChoiceInstruction::Trust(ref mut i)) => {
+                    *i += prelude_length - index;
+                }
+                _ => {
                 }
-                _ => {}
             }
         }
 
         let str_loc = Self::switch_on_str_offset_from(str_loc, prelude.len(), con_loc);
         let con_loc = Self::switch_on_con_offset_from(con_loc, prelude.len());
-        let lst_loc = Self::switch_on_lst_offset_from(lst_loc, prelude.len(), lst_offset);
+        let lst_loc = Self::switch_on_lst_offset_from(lst_loc, prelude.len());
 
         let switch_instr =
             IndexingInstruction::SwitchOnTerm(prelude.len() + 1, con_loc, lst_loc, str_loc);

src/prolog/instructions.rs

@@ -2,28 +2,29 @@ use 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 indexmap::IndexMap;
 
 use std::collections::VecDeque;
+use std::rc::Rc;
 
 fn reg_type_into_functor(r: RegType) -> MachineStub {
     match r {
-        RegType::Temp(r) => functor!("x", 1, [heap_integer!(Integer::from(r))]),
-        RegType::Perm(r) => functor!("y", 1, [heap_integer!(Integer::from(r))]),
+        RegType::Temp(r) => functor!("x", [integer(r)]),
+        RegType::Perm(r) => functor!("y", [integer(r)]),
     }
 }
 
 impl Level {
     fn into_functor(self) -> MachineStub {
         match self {
-            Level::Root => functor!("level", 1, [heap_atom!("root")]),
-            Level::Shallow => functor!("level", 1, [heap_atom!("shallow")]),
-            Level::Deep => functor!("level", 1, [heap_atom!("deep")]),
+            Level::Root => functor!("level", [atom("root")]),
+            Level::Shallow => functor!("level", [atom("shallow")]),
+            Level::Deep => functor!("level", [atom("deep")]),
         }
     }
 }
@@ -31,11 +32,15 @@ impl Level {
 impl ArithmeticTerm {
     fn into_functor(&self) -> MachineStub {
         match self {
-            &ArithmeticTerm::Reg(r) => reg_type_into_functor(r),
-            &ArithmeticTerm::Interm(i) => {
-                functor!("intermediate", 1, [heap_integer!(Integer::from(i))])
+            &ArithmeticTerm::Reg(r) => {
+                reg_type_into_functor(r)
+            }
+            &ArithmeticTerm::Interm(i) => {
+                functor!("intermediate", [integer(i)])
+            }
+            &ArithmeticTerm::Number(ref n) => {
+                vec![n.clone().into()]
             }
-            &ArithmeticTerm::Number(ref n) => vec![heap_con!(n.clone().to_constant())],
         }
     }
 }
@@ -52,18 +57,20 @@ impl ChoiceInstruction {
     pub fn to_functor(&self) -> MachineStub {
         match self {
             &ChoiceInstruction::TryMeElse(offset) => {
-                functor!("try_me_else", 1, [heap_integer!(Integer::from(offset))])
+                functor!("try_me_else", [integer(offset)])
             }
             &ChoiceInstruction::RetryMeElse(offset) => {
-                functor!("retry_me_else", 1, [heap_integer!(Integer::from(offset))])
+                functor!("retry_me_else", [integer(offset)])
+            }
+            &ChoiceInstruction::TrustMe => {
+                functor!("trust_me")
+            }
+            &ChoiceInstruction::DefaultRetryMeElse(offset) => {
+                functor!("default_retry_me_else", [integer(offset)])
+            }
+            &ChoiceInstruction::DefaultTrustMe => {
+                functor!("default_trust_me")
             }
-            &ChoiceInstruction::TrustMe => vec![heap_atom!("trust_me")],
-            &ChoiceInstruction::DefaultRetryMeElse(offset) => functor!(
-                "default_retry_me_else",
-                1,
-                [heap_integer!(Integer::from(offset))]
-            ),
-            &ChoiceInstruction::DefaultTrustMe => vec![heap_atom!("default_trust_me")],
         }
     }
 }
@@ -79,21 +86,20 @@ impl CutInstruction {
     pub fn to_functor(&self, h: usize) -> MachineStub {
         match self {
             &CutInstruction::Cut(r) => {
-                let mut stub = functor!("cut", 1, [heap_str!(h + 2)]);
-                stub.append(&mut reg_type_into_functor(r));
-                stub
+                let rt_stub = reg_type_into_functor(r);
+                functor!("cut", [aux(h, 0)], [rt_stub])
             }
             &CutInstruction::GetLevel(r) => {
-                let mut stub = functor!("get_level", 1, [heap_str!(h + 2)]);
-                stub.append(&mut reg_type_into_functor(r));
-                stub
+                let rt_stub = reg_type_into_functor(r);
+                functor!("get_level", [aux(h, 0)], [rt_stub])
             }
             &CutInstruction::GetLevelAndUnify(r) => {
-                let mut stub = functor!("get_level_and_unify", 1, [heap_str!(h + 2)]);
-                stub.append(&mut reg_type_into_functor(r));
-                stub
+                let rt_stub = reg_type_into_functor(r);
+                functor!("get_level_and_unify", [aux(h, 0)], [rt_stub])
+            }
+            &CutInstruction::NeckCut => {
+                functor!("neck_cut")
             }
-            &CutInstruction::NeckCut => vec![heap_atom!("neck_cut")],
         }
     }
 }
@@ -122,13 +128,13 @@ impl IndexedChoiceInstruction {
     pub fn to_functor(&self) -> MachineStub {
         match self {
             &IndexedChoiceInstruction::Try(offset) => {
-                functor!("try", 1, [heap_integer!(Integer::from(offset))])
+                functor!("try", [integer(offset)])
             }
             &IndexedChoiceInstruction::Trust(offset) => {
-                functor!("trust", 1, [heap_integer!(Integer::from(offset))])
+                functor!("trust", [integer(offset)])
             }
             &IndexedChoiceInstruction::Retry(offset) => {
-                functor!("retry", 1, [heap_integer!(Integer::from(offset))])
+                functor!("retry", [integer(offset)])
             }
         }
     }
@@ -189,6 +195,8 @@ pub enum ArithmeticInstruction {
     Or(ArithmeticTerm, ArithmeticTerm, usize),
     Mod(ArithmeticTerm, ArithmeticTerm, usize),
     Rem(ArithmeticTerm, ArithmeticTerm, usize),
+    Gcd(ArithmeticTerm, ArithmeticTerm, usize),
+    Sign(ArithmeticTerm, usize),
     Cos(ArithmeticTerm, usize),
     Sin(ArithmeticTerm, usize),
     Tan(ArithmeticTerm, usize),
@@ -218,14 +226,11 @@ fn arith_instr_unary_functor(
 ) -> MachineStub {
     let at_stub = at.into_functor();
 
-    let mut stub = functor!(
+    functor!(
         name,
-        2,
-        [heap_cell!(h + 4), heap_integer!(Integer::from(t))]
-    );
-
-    stub.extend(at_stub.into_iter());
-    stub
+        [aux(h, 0), integer(t)],
+        [at_stub]
+    )
 }
 
 fn arith_instr_bin_functor(
@@ -238,20 +243,11 @@ fn arith_instr_bin_functor(
     let at_1_stub = at_1.into_functor();
     let at_2_stub = at_2.into_functor();
 
-    let mut stub = functor!(
+    functor!(
         name,
-        3,
-        [
-            heap_cell!(h + 4),
-            heap_cell!(h + 4 + at_1_stub.len()),
-            heap_integer!(Integer::from(t))
-        ]
-    );
-
-    stub.extend(at_1_stub.into_iter());
-    stub.extend(at_2_stub.into_iter());
-
-    stub
+        [aux(h, 0), aux(h, 1), integer(t)],
+        [at_1_stub, at_2_stub]
+    )
 }
 
 impl ArithmeticInstruction {
@@ -314,16 +310,42 @@ impl ArithmeticInstruction {
             &ArithmeticInstruction::ATan2(ref at_1, ref at_2, t) => {
                 arith_instr_bin_functor(h, "rem", at_1, at_2, t)
             }
-            &ArithmeticInstruction::Cos(ref at, t) => arith_instr_unary_functor(h, "cos", at, t),
-            &ArithmeticInstruction::Sin(ref at, t) => arith_instr_unary_functor(h, "sin", at, t),
-            &ArithmeticInstruction::Tan(ref at, t) => arith_instr_unary_functor(h, "tan", at, t),
-            &ArithmeticInstruction::Log(ref at, t) => arith_instr_unary_functor(h, "log", at, t),
-            &ArithmeticInstruction::Exp(ref at, t) => arith_instr_unary_functor(h, "exp", at, t),
-            &ArithmeticInstruction::ACos(ref at, t) => arith_instr_unary_functor(h, "acos", at, t),
-            &ArithmeticInstruction::ASin(ref at, t) => arith_instr_unary_functor(h, "asin", at, t),
-            &ArithmeticInstruction::ATan(ref at, t) => arith_instr_unary_functor(h, "atan", at, t),
-            &ArithmeticInstruction::Sqrt(ref at, t) => arith_instr_unary_functor(h, "sqrt", at, t),
-            &ArithmeticInstruction::Abs(ref at, t) => arith_instr_unary_functor(h, "abs", at, t),
+            &ArithmeticInstruction::Gcd(ref at_1, ref at_2, t) => {
+                arith_instr_bin_functor(h, "gcd", at_1, at_2, t)
+            }
+            &ArithmeticInstruction::Sign(ref at, t) => {
+                arith_instr_unary_functor(h, "sign", at, t)
+            }
+            &ArithmeticInstruction::Cos(ref at, t)  => {
+                arith_instr_unary_functor(h, "cos", at, t)
+            }
+            &ArithmeticInstruction::Sin(ref at, t)  => {
+                arith_instr_unary_functor(h, "sin", at, t)
+            }
+            &ArithmeticInstruction::Tan(ref at, t)  => {
+                arith_instr_unary_functor(h, "tan", at, t)
+            }
+            &ArithmeticInstruction::Log(ref at, t)  => {
+                arith_instr_unary_functor(h, "log", at, t)
+            }
+            &ArithmeticInstruction::Exp(ref at, t)  => {
+                arith_instr_unary_functor(h, "exp", at, t)
+            }
+            &ArithmeticInstruction::ACos(ref at, t) => {
+                arith_instr_unary_functor(h, "acos", at, t)
+            }
+            &ArithmeticInstruction::ASin(ref at, t) => {
+                arith_instr_unary_functor(h, "asin", at, t)
+            }
+            &ArithmeticInstruction::ATan(ref at, t) => {
+                arith_instr_unary_functor(h, "atan", at, t)
+            }
+            &ArithmeticInstruction::Sqrt(ref at, t) => {
+                arith_instr_unary_functor(h, "sqrt", at, t)
+            }
+            &ArithmeticInstruction::Abs(ref at, t) => {
+                arith_instr_unary_functor(h, "abs", at, t)
+            }
             &ArithmeticInstruction::Float(ref at, t) => {
                 arith_instr_unary_functor(h, "float", at, t)
             }
@@ -339,8 +361,12 @@ impl ArithmeticInstruction {
             &ArithmeticInstruction::Floor(ref at, t) => {
                 arith_instr_unary_functor(h, "floor", at, t)
             }
-            &ArithmeticInstruction::Neg(ref at, t) => arith_instr_unary_functor(h, "-", at, t),
-            &ArithmeticInstruction::Plus(ref at, t) => arith_instr_unary_functor(h, "+", at, t),
+            &ArithmeticInstruction::Neg(ref at, t) => {
+                arith_instr_unary_functor(h, "-", at, t)
+            }
+            &ArithmeticInstruction::Plus(ref at, t) => {
+                arith_instr_unary_functor(h, "+", at, t)
+            }
             &ArithmeticInstruction::BitwiseComplement(ref at, t) => {
                 arith_instr_unary_functor(h, "\\", at, t)
             }
@@ -358,40 +384,37 @@ pub enum ControlInstruction {
 }
 
 impl ControlInstruction {
-    pub fn is_jump_instr(&self) -> bool {
+    pub fn perm_vars(&self) -> Option<usize> {
         match self {
-            &ControlInstruction::CallClause(..) => true,
-            &ControlInstruction::JmpBy(..) => true,
-            _ => false,
+            ControlInstruction::CallClause(_, _, num_cells, ..) =>
+                Some(*num_cells),
+            ControlInstruction::JmpBy(_, _, num_cells, ..) =>
+                Some(*num_cells),
+            _ =>
+                None
         }
     }
 
     pub fn to_functor(&self) -> MachineStub {
         match self {
             &ControlInstruction::Allocate(num_frames) => {
-                functor!("allocate", 1, [heap_integer!(Integer::from(num_frames))])
+                functor!("allocate", [integer(num_frames)])
+            }
+            &ControlInstruction::CallClause(ref ct, arity, _, false, _) => {
+                functor!("call", [clause_name(ct.name()), integer(arity)])
+            }
+            &ControlInstruction::CallClause(ref ct, arity, _, true, _) => {
+                functor!("execute", [clause_name(ct.name()), integer(arity)])
+            }
+            &ControlInstruction::Deallocate => {
+                functor!("deallocate")
             }
-            &ControlInstruction::CallClause(ref ct, arity, _, false, _) => functor!(
-                "call",
-                2,
-                [
-                    heap_con!(Constant::Atom(ct.name(), None)),
-                    heap_integer!(Integer::from(arity))
-                ]
-            ),
-            &ControlInstruction::CallClause(ref ct, arity, _, true, _) => functor!(
-                "execute",
-                2,
-                [
-                    heap_con!(Constant::Atom(ct.name(), None)),
-                    heap_integer!(Integer::from(arity))
-                ]
-            ),
-            &ControlInstruction::Deallocate => vec![heap_atom!("deallocate")],
             &ControlInstruction::JmpBy(_, offset, ..) => {
-                functor!("jmp_by", 1, [heap_integer!(Integer::from(offset))])
+                functor!("jmp_by", [integer(offset)])
+            }
+            &ControlInstruction::Proceed => {
+                functor!("proceed")
             }
-            &ControlInstruction::Proceed => vec![heap_atom!("proceed")],
         }
     }
 }
@@ -411,26 +434,27 @@ impl From<IndexingInstruction> for Line {
 impl IndexingInstruction {
     pub fn to_functor(&self) -> MachineStub {
         match self {
-            &IndexingInstruction::SwitchOnTerm(vars, constants, lists, structures) => functor!(
-                "switch_on_term",
-                4,
-                [
-                    heap_integer!(Integer::from(vars)),
-                    heap_integer!(Integer::from(constants)),
-                    heap_integer!(Integer::from(lists)),
-                    heap_integer!(Integer::from(structures))
-                ]
-            ),
-            &IndexingInstruction::SwitchOnConstant(constants, _) => functor!(
-                "switch_on_constant",
-                1,
-                [heap_integer!(Integer::from(constants))]
-            ),
-            &IndexingInstruction::SwitchOnStructure(structures, _) => functor!(
-                "switch_on_structure",
-                1,
-                [heap_integer!(Integer::from(structures))]
-            ),
+            &IndexingInstruction::SwitchOnTerm(vars, constants, lists, structures) => {
+                functor!(
+                    "switch_on_term",
+                    [integer(vars),
+                     integer(constants),
+                     integer(lists),
+                     integer(structures)]
+                )
+            }
+            &IndexingInstruction::SwitchOnConstant(constants, _) => {
+                functor!(
+                    "switch_on_constant",
+                    [integer(constants)]
+                )
+            }
+            &IndexingInstruction::SwitchOnStructure(structures, _) => {
+                functor!(
+                    "switch_on_structure",
+                    [integer(structures)]
+                )
+            }
         }
     }
 }
@@ -439,6 +463,7 @@ impl IndexingInstruction {
 pub enum FactInstruction {
     GetConstant(Level, Constant, RegType),
     GetList(Level, RegType),
+    GetPartialString(Level, String, RegType, bool),
     GetStructure(ClauseType, usize, RegType),
     GetValue(RegType, usize),
     GetVariable(RegType, usize),
@@ -452,86 +477,95 @@ pub enum FactInstruction {
 impl FactInstruction {
     pub fn to_functor(&self, h: usize) -> MachineStub {
         match self {
-            &FactInstruction::GetConstant(lvl, ref constant, r) => {
-                let mut stub = functor!(
+            &FactInstruction::GetConstant(lvl, ref c, r) => {
+                let lvl_stub = lvl.into_functor();
+                let rt_stub  = reg_type_into_functor(r);
+
+                functor!(
                     "get_constant",
-                    3,
-                    [
-                        heap_str!(h + 4),
-                        heap_con!(constant.clone()),
-                        heap_str!(h + 6)
-                    ]
-                );
-
-                stub.append(&mut lvl.into_functor());
-                stub.append(&mut reg_type_into_functor(r));
-
-                stub
+                    [aux(h, 0), constant(h, c), aux(h, 1)],
+                    [lvl_stub, rt_stub]
+                )
             }
             &FactInstruction::GetList(lvl, r) => {
-                let mut stub = functor!("get_list", 2, [heap_str!(h + 3), heap_str!(h + 5)]);
-                stub.append(&mut lvl.into_functor());
-                stub.append(&mut reg_type_into_functor(r));
+                let lvl_stub = lvl.into_functor();
+                let rt_stub  = reg_type_into_functor(r);
 
-                stub
+                functor!(
+                    "get_list",
+                    [aux(h, 0), aux(h, 1)],
+                    [lvl_stub, rt_stub]
+                )
+            }
+            &FactInstruction::GetPartialString(lvl, ref s, r, has_tail) => {
+                let lvl_stub = lvl.into_functor();
+                let rt_stub  = reg_type_into_functor(r);
+
+                functor!(
+                    "get_partial_string",
+                    [aux(h, 0), string(h, s), aux(h, 1), boolean(has_tail)],
+                    [lvl_stub, rt_stub]
+                )
             }
             &FactInstruction::GetStructure(ref ct, arity, r) => {
-                let mut stub = functor!(
-                    "get_structure",
-                    3,
-                    [
-                        heap_con!(Constant::Atom(ct.name(), None)),
-                        heap_integer!(Integer::from(arity)),
-                        heap_str!(h + 4)
-                    ]
-                );
-                stub.append(&mut reg_type_into_functor(r));
+                let rt_stub = reg_type_into_functor(r);
 
-                stub
+                functor!(
+                    "get_structure",
+                    [clause_name(ct.name()), integer(arity), aux(h, 0)],
+                    [rt_stub]
+                )
             }
             &FactInstruction::GetValue(r, arg) => {
-                let mut stub = functor!(
-                    "get_value",
-                    2,
-                    [heap_str!(h + 3), heap_integer!(Integer::from(arg))]
-                );
-                stub.append(&mut reg_type_into_functor(r));
+                let rt_stub = reg_type_into_functor(r);
 
-                stub
+                functor!(
+                    "get_value",
+                    [aux(h, 0), integer(arg)],
+                    [rt_stub]
+                )
             }
             &FactInstruction::GetVariable(r, arg) => {
-                let mut stub = functor!(
-                    "get_variable",
-                    2,
-                    [heap_str!(h + 3), heap_integer!(Integer::from(arg))]
-                );
-                stub.append(&mut reg_type_into_functor(r));
+                let rt_stub = reg_type_into_functor(r);
 
-                stub
+                functor!(
+                    "get_variable",
+                    [aux(h, 0), integer(arg)],
+                    [rt_stub]
+                )
             }
-            &FactInstruction::UnifyConstant(ref constant) => {
-                functor!("unify_constant", 1, [heap_con!(constant.clone())])
+            &FactInstruction::UnifyConstant(ref c) => {
+                functor!("unify_constant", [constant(h, c)], [])
             }
             &FactInstruction::UnifyLocalValue(r) => {
-                let mut stub = functor!("unify_local_value", 1, [heap_str!(h + 2)]);
-                stub.append(&mut reg_type_into_functor(r));
+                let rt_stub = reg_type_into_functor(r);
 
-                stub
+                functor!(
+                    "unify_local_value",
+                    [aux(h, 0)],
+                    [rt_stub]
+                )
             }
             &FactInstruction::UnifyVariable(r) => {
-                let mut stub = functor!("unify_variable", 1, [heap_str!(h + 2)]);
-                stub.append(&mut reg_type_into_functor(r));
+                let rt_stub = reg_type_into_functor(r);
 
-                stub
+                functor!(
+                    "unify_variable",
+                    [aux(h, 0)],
+                    [rt_stub]
+                )
             }
             &FactInstruction::UnifyValue(r) => {
-                let mut stub = functor!("unify_value", 1, [heap_str!(h + 2)]);
-                stub.append(&mut reg_type_into_functor(r));
+                let rt_stub = reg_type_into_functor(r);
 
-                stub
+                functor!(
+                    "unify_value",
+                    [aux(h, 0)],
+                    [rt_stub]
+                )
             }
             &FactInstruction::UnifyVoid(vars) => {
-                functor!("unify_void", 1, [heap_integer!(Integer::from(vars))])
+                functor!("unify_void", [integer(vars)])
             }
         }
     }
@@ -542,6 +576,7 @@ pub enum QueryInstruction {
     GetVariable(RegType, usize),
     PutConstant(Level, Constant, RegType),
     PutList(Level, RegType),
+    PutPartialString(Level, String, RegType, bool),
     PutStructure(ClauseType, usize, RegType),
     PutUnsafeValue(usize, usize),
     PutValue(RegType, usize),
@@ -558,103 +593,106 @@ impl QueryInstruction {
         match self {
             &QueryInstruction::PutUnsafeValue(norm, arg) => functor!(
                 "put_unsafe_value",
-                2,
-                [
-                    heap_integer!(Integer::from(norm)),
-                    heap_integer!(Integer::from(arg))
-                ]
+                [integer(norm), integer(arg)]
             ),
-            &QueryInstruction::PutConstant(lvl, ref constant, r) => {
-                let mut stub = functor!(
+            &QueryInstruction::PutConstant(lvl, ref c, r) => {
+                let lvl_stub = lvl.into_functor();
+                let rt_stub  = reg_type_into_functor(r);
+
+                functor!(
                     "put_constant",
-                    3,
-                    [
-                        heap_str!(h + 4),
-                        heap_con!(constant.clone()),
-                        heap_str!(h + 6)
-                    ]
-                );
-
-                stub.append(&mut lvl.into_functor());
-                stub.append(&mut reg_type_into_functor(r));
-
-                stub
+                    [aux(h, 0), constant(h, c), aux(h, 1)],
+                    [lvl_stub, rt_stub]
+                )
             }
             &QueryInstruction::PutList(lvl, r) => {
-                let mut stub = functor!("put_list", 2, [heap_str!(h + 3), heap_str!(h + 5)]);
+                let lvl_stub = lvl.into_functor();
+                let rt_stub  = reg_type_into_functor(r);
 
-                stub.append(&mut lvl.into_functor());
-                stub.append(&mut reg_type_into_functor(r));
+                functor!(
+                    "put_list",
+                    [aux(h, 0), aux(h, 1)],
+                    [lvl_stub, rt_stub]
+                )
+            }
+            &QueryInstruction::PutPartialString(lvl, ref s, r, has_tail) => {
+                let lvl_stub = lvl.into_functor();
+                let rt_stub  = reg_type_into_functor(r);
 
-                stub
+                functor!(
+                    "put_partial_string",
+                    [aux(h, 0), string(h, s), aux(h, 1), boolean(has_tail)],
+                    [lvl_stub, rt_stub]
+                )
             }
             &QueryInstruction::PutStructure(ref ct, arity, r) => {
-                let mut stub = functor!(
-                    "put_structure",
-                    3,
-                    [
-                        heap_con!(Constant::Atom(ct.name(), None)),
-                        heap_integer!(Integer::from(arity)),
-                        heap_str!(h + 4)
-                    ]
-                );
+                let rt_stub = reg_type_into_functor(r);
 
-                stub.append(&mut reg_type_into_functor(r));
-                stub
+                functor!(
+                    "put_structure",
+                    [clause_name(ct.name()), integer(arity), aux(h, 0)],
+                    [rt_stub]
+                )
             }
             &QueryInstruction::PutValue(r, arg) => {
-                let mut stub = functor!(
-                    "put_value",
-                    2,
-                    [heap_str!(h + 3), heap_integer!(Integer::from(arg))]
-                );
+                let rt_stub = reg_type_into_functor(r);
 
-                stub.append(&mut reg_type_into_functor(r));
-                stub
+                functor!(
+                    "put_value",
+                    [aux(h, 0), integer(arg)],
+                    [rt_stub]
+                )
             }
             &QueryInstruction::GetVariable(r, arg) => {
-                let mut stub = functor!(
-                    "get_variable",
-                    2,
-                    [heap_str!(h + 3), heap_integer!(Integer::from(arg))]
-                );
+                let rt_stub = reg_type_into_functor(r);
 
-                stub.append(&mut reg_type_into_functor(r));
-                stub
+                functor!(
+                    "get_variable",
+                    [aux(h, 0), integer(arg)],
+                    [rt_stub]
+                )
             }
             &QueryInstruction::PutVariable(r, arg) => {
-                let mut stub = functor!(
-                    "put_variable",
-                    2,
-                    [heap_str!(h + 3), heap_integer!(Integer::from(arg))]
-                );
+                let rt_stub = reg_type_into_functor(r);
 
-                stub.append(&mut reg_type_into_functor(r));
-                stub
+                functor!(
+                    "put_variable",
+                    [aux(h, 0), integer(arg)],
+                    [rt_stub]
+                )
             }
-            &QueryInstruction::SetConstant(ref constant) => {
-                functor!("set_constant", 1, [heap_con!(constant.clone())])
+            &QueryInstruction::SetConstant(ref c) => {
+                functor!("set_constant", [constant(h, c)], [])
             }
             &QueryInstruction::SetLocalValue(r) => {
-                let mut stub = functor!("set_local_value", 1, [heap_str!(h + 2)]);
+                let rt_stub = reg_type_into_functor(r);
 
-                stub.append(&mut reg_type_into_functor(r));
-                stub
+                functor!(
+                    "set_local_value",
+                    [aux(h, 0)],
+                    [rt_stub]
+                )
             }
             &QueryInstruction::SetVariable(r) => {
-                let mut stub = functor!("set_variable", 1, [heap_str!(h + 2)]);
+                let rt_stub = reg_type_into_functor(r);
 
-                stub.append(&mut reg_type_into_functor(r));
-                stub
+                functor!(
+                    "set_variable",
+                    [aux(h, 0)],
+                    [rt_stub]
+                )
             }
             &QueryInstruction::SetValue(r) => {
-                let mut stub = functor!("set_value", 1, [heap_str!(h + 2)]);
+                let rt_stub = reg_type_into_functor(r);
 
-                stub.append(&mut reg_type_into_functor(r));
-                stub
+                functor!(
+                    "set_value",
+                    [aux(h, 0)],
+                    [rt_stub]
+                )
             }
             &QueryInstruction::SetVoid(vars) => {
-                functor!("set_void", 1, [heap_integer!(Integer::from(vars))])
+                functor!("set_void", [integer(vars)])
             }
         }
     }

src/prolog/iterators.rs

@@ -16,6 +16,7 @@ pub enum TermRef<'a> {
     Cons(Level, &'a Cell<RegType>, &'a Term, &'a Term),
     Constant(Level, &'a Cell<RegType>, &'a Constant),
     Clause(Level, &'a Cell<RegType>, ClauseType, &'a Vec<Box<Term>>),
+    PartialString(Level, &'a Cell<RegType>, String, Option<&'a Term>),
     Var(Level, &'a Cell<VarReg>, Rc<Var>),
 }
 
@@ -27,6 +28,7 @@ impl<'a> TermRef<'a> {
           | TermRef::Constant(lvl, ..)
           | TermRef::Var(lvl, ..)
           | TermRef::Clause(lvl, ..) => lvl,
+          | TermRef::PartialString(lvl, ..) => lvl,
         }
     }
 }
@@ -43,13 +45,63 @@ pub enum TermIterState<'a> {
     ),
     InitialCons(Level, &'a Cell<RegType>, &'a Term, &'a Term),
     FinalCons(Level, &'a Cell<RegType>, &'a Term, &'a Term),
+    PartialString(Level, &'a Cell<RegType>, String, Option<&'a Term>),
     Var(Level, &'a Cell<VarReg>, Rc<Var>),
 }
 
+fn is_partial_string<'a>(
+    head: &'a Term,
+    mut tail: &'a Term,
+) -> Option<(String, Option<&'a Term>)>
+{
+    let mut string =
+        match head {
+            &Term::Constant(_, Constant::Atom(ref atom, _)) if atom.is_char() => {
+                atom.as_str().chars().next().unwrap().to_string()
+            }
+            &Term::Constant(_, Constant::Char(c)) => {
+                c.to_string()
+            }
+            _ => {
+                return None;
+            }
+        };
+
+    while let Term::Cons(_, ref head, ref succ) = tail {
+        match head.as_ref() {
+            &Term::Constant(_, Constant::Atom(ref atom, _)) if atom.is_char() => {
+                string.push(atom.as_str().chars().next().unwrap());
+            }
+            &Term::Constant(_, Constant::Char(c)) => {
+                string.push(c);
+            }
+            _ => {
+                return None;
+            }
+        };
+
+        tail = succ.as_ref();
+    }
+
+    match tail {
+        Term::AnonVar | Term::Var(..) => {
+            return Some((string, Some(tail)));
+        }
+        Term::Constant(_, Constant::EmptyList) => {
+            return Some((string, None));
+        }
+        _ => {
+            return None;
+        }
+    }
+}
+
 impl<'a> TermIterState<'a> {
     pub fn subterm_to_state(lvl: Level, term: &'a Term) -> TermIterState<'a> {
         match term {
-            &Term::AnonVar => TermIterState::AnonVar(lvl),
+            &Term::AnonVar => {
+                TermIterState::AnonVar(lvl)
+            }
             &Term::Clause(ref cell, ref name, ref subterms, ref spec) => {
                 let ct = if let Some(spec) = spec {
                     ClauseType::Op(name.clone(), spec.clone(), CodeIndex::default())
@@ -62,8 +114,12 @@ impl<'a> TermIterState<'a> {
             &Term::Cons(ref cell, ref head, ref tail) => {
                 TermIterState::InitialCons(lvl, cell, head.as_ref(), tail.as_ref())
             }
-            &Term::Constant(ref cell, ref constant) => TermIterState::Constant(lvl, cell, constant),
-            &Term::Var(ref cell, ref var) => TermIterState::Var(lvl, cell, var.clone()),
+            &Term::Constant(ref cell, ref constant) => {
+                TermIterState::Constant(lvl, cell, constant)
+            }
+            &Term::Var(ref cell, ref var) => {
+                TermIterState::Var(lvl, cell, var.clone())
+            }
         }
     }
 }
@@ -169,7 +225,9 @@ impl<'a> Iterator for QueryIterator<'a> {
     fn next(&mut self) -> Option<Self::Item> {
         while let Some(iter_state) = self.state_stack.pop() {
             match iter_state {
-                TermIterState::AnonVar(lvl) => return Some(TermRef::AnonVar(lvl)),
+                TermIterState::AnonVar(lvl) => {
+                    return Some(TermRef::AnonVar(lvl));
+                }
                 TermIterState::Clause(lvl, child_num, cell, ct, child_terms) => {
                     if child_num == child_terms.len() {
                         match ct {
@@ -182,7 +240,9 @@ impl<'a> Iterator for QueryIterator<'a> {
                                     lvl => Some(TermRef::Clause(lvl, cell, ct, child_terms)),
                                 }
                             }
-                            _ => return None,
+                            _ => {
+                                return None;
+                            }
                         };
                     } else {
                         self.state_stack.push(TermIterState::Clause(
@@ -192,23 +252,41 @@ impl<'a> Iterator for QueryIterator<'a> {
                             ct,
                             child_terms,
                         ));
+
                         self.push_subterm(lvl.child_level(), child_terms[child_num].as_ref());
                     }
                 }
                 TermIterState::InitialCons(lvl, cell, head, tail) => {
-                    self.state_stack
-                        .push(TermIterState::FinalCons(lvl, cell, head, tail));
+                    if let Some((string, tail)) = is_partial_string(head, tail) {
+                        self.state_stack.push(TermIterState::PartialString(
+                            lvl,
+                            cell,
+                            string,
+                            tail,
+                        ));
 
-                    self.push_subterm(lvl.child_level(), tail);
-                    self.push_subterm(lvl.child_level(), head);
+                        if let Some(tail) = tail {
+                            self.push_subterm(lvl.child_level(), tail);
+                        }
+                    } else {
+                        self.state_stack.push(TermIterState::FinalCons(lvl, cell, head, tail));
+
+                        self.push_subterm(lvl.child_level(), tail);
+                        self.push_subterm(lvl.child_level(), head);
+                    }
+                }
+                TermIterState::PartialString(lvl, cell, string, tail) => {
+                    return Some(TermRef::PartialString(lvl, cell, string, tail));
                 }
                 TermIterState::FinalCons(lvl, cell, head, tail) => {
-                    return Some(TermRef::Cons(lvl, cell, head, tail))
+                    return Some(TermRef::Cons(lvl, cell, head, tail));
                 }
                 TermIterState::Constant(lvl, cell, constant) => {
-                    return Some(TermRef::Constant(lvl, cell, constant))
+                    return Some(TermRef::Constant(lvl, cell, constant));
+                }
+                TermIterState::Var(lvl, cell, var) => {
+                    return Some(TermRef::Var(lvl, cell, var));
                 }
-                TermIterState::Var(lvl, cell, var) => return Some(TermRef::Var(lvl, cell, var)),
             };
         }
 
@@ -223,8 +301,7 @@ pub struct FactIterator<'a> {
 
 impl<'a> FactIterator<'a> {
     fn push_subterm(&mut self, lvl: Level, term: &'a Term) {
-        self.state_queue
-            .push_back(TermIterState::subterm_to_state(lvl, term));
+        self.state_queue.push_back(TermIterState::subterm_to_state(lvl, term));
     }
 
     pub fn from_rule_head_clause(terms: &'a Vec<Box<Term>>) -> Self {
@@ -241,7 +318,9 @@ impl<'a> FactIterator<'a> {
 
     fn new(term: &'a Term, iterable_root: bool) -> Self {
         let states = match term {
-            &Term::AnonVar => vec![TermIterState::AnonVar(Level::Root)],
+            &Term::AnonVar => {
+                vec![TermIterState::AnonVar(Level::Root)]
+            }
             &Term::Clause(ref cell, ref name, ref terms, ref fixity) => {
                 let ct = ClauseType::from(name.clone(), terms.len(), fixity.clone());
                 vec![TermIterState::Clause(Level::Root, 0, cell, ct, terms)]
@@ -273,7 +352,9 @@ impl<'a> Iterator for FactIterator<'a> {
     fn next(&mut self) -> Option<Self::Item> {
         while let Some(state) = self.state_queue.pop_front() {
             match state {
-                TermIterState::AnonVar(lvl) => return Some(TermRef::AnonVar(lvl)),
+                TermIterState::AnonVar(lvl) => {
+                    return Some(TermRef::AnonVar(lvl));
+                }
                 TermIterState::Clause(lvl, _, cell, ct, child_terms) => {
                     for child_term in child_terms {
                         self.push_subterm(lvl.child_level(), child_term);
@@ -285,16 +366,27 @@ impl<'a> Iterator for FactIterator<'a> {
                     };
                 }
                 TermIterState::InitialCons(lvl, cell, head, tail) => {
-                    self.push_subterm(Level::Deep, head);
-                    self.push_subterm(Level::Deep, tail);
+                    if let Some((string, tail)) = is_partial_string(head, tail) {
+                        if let Some(tail) = tail {
+                            self.push_subterm(Level::Deep, tail);
+                        }
 
-                    return Some(TermRef::Cons(lvl, cell, head, tail));
+                        return Some(TermRef::PartialString(lvl, cell, string, tail));
+                    } else {
+                        self.push_subterm(Level::Deep, head);
+                        self.push_subterm(Level::Deep, tail);
+
+                        return Some(TermRef::Cons(lvl, cell, head, tail));
+                    }
                 }
                 TermIterState::Constant(lvl, cell, constant) => {
                     return Some(TermRef::Constant(lvl, cell, constant))
                 }
-                TermIterState::Var(lvl, cell, var) => return Some(TermRef::Var(lvl, cell, var)),
-                _ => {}
+                TermIterState::Var(lvl, cell, var) => {
+                    return Some(TermRef::Var(lvl, cell, var));
+                }
+                _ => {
+                }
             }
         }
 

src/prolog/lib/assoc.pl

@@ -63,12 +63,12 @@ Assocs are Key-Value associations implemented as  a balanced binary tree
 @author         R.A.O'Keefe, L.Damas, V.S.Costa and Jan Wielemaker
 */
 
-/*					  
+/*
 :- meta_predicate
     map_assoc(1, ?),
     map_assoc(2, ?, ?).
 */
-					  
+
 %!  empty_assoc(?Assoc) is semidet.
 %
 %   Is true if Assoc is the empty association list.

src/prolog/lib/atts.pl

@@ -1,14 +1,13 @@
-:- module(atts, [attribute/1, 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]).
+:- 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]).
 
 :- use_module(library(dcgs)).
 :- use_module(library(terms)).
 
-:- op(1199, fx, attribute).
-
 /* represent the list of attributes belonging to a variable,
    of a particular module, as a list of terms of the form
    Module:put_atts(V, ListOfAtts). */
@@ -20,7 +19,7 @@
 
 '$default_attr_list'([PG | PGs], Module, AttrVar) -->
     (  { '$module_of'(Module, PG) } -> [Module:put_atts(AttrVar, PG)]
-    ;  true
+    ;  { true }
     ),
     '$default_attr_list'(PGs, Module, AttrVar).
 '$default_attr_list'([], _, _) --> [].
@@ -29,26 +28,26 @@
     '$get_attr_list'(V, Ls),
     '$absent_from_list'(Ls, Attr).
 
-'$absent_from_list'(X, _) :-
-    var(X), !.
-'$absent_from_list'([L|Ls], Attr) :-
-    ( L \= Attr -> '$absent_from_list'(Ls, Attr) ).
+'$absent_from_list'(X, Attr) :-
+    (  var(X) -> true
+    ;  X = [L|Ls], L \= Attr -> '$absent_from_list'(Ls, Attr)
+    ).
 
 '$get_attr'(V, Attr) :-
     '$get_attr_list'(V, Ls), nonvar(Ls), '$get_from_list'(Ls, V, Attr).
 
 '$get_from_list'([L|Ls], V, Attr) :-
     nonvar(L),
-    ( L \= Attr -> nonvar(Ls), '$get_from_list'(Ls, V, Attr)
-    ; L = Attr -> '$enqueue_attr_var'(V)
-    ; '$get_from_list'(Ls, V, Attr)
+    (  L \= Attr -> nonvar(Ls), '$get_from_list'(Ls, V, Attr)
+    ;  L = Attr, '$enqueue_attr_var'(V)
     ).
 
 '$put_attr'(V, Attr) :-
     '$get_attr_list'(V, Ls), '$add_to_list'(Ls, V, Attr).
 
 '$add_to_list'(Ls, V, Attr) :-
-    ( var(Ls) -> Ls = [Attr | _], '$enqueue_attr_var'(V)
+    ( var(Ls) ->
+      Ls = [Attr | _], '$enqueue_attr_var'(V)
     ; Ls = [_ | Ls0], '$add_to_list'(Ls0, V, Attr)
     ).
 
@@ -57,26 +56,27 @@
 '$del_attr'(Ls0, V, Attr) :-
     Ls0 = [Att | Ls1],
     nonvar(Att),
-    ( Att \= Attr -> '$del_attr_buried'(Ls0, Ls1, V, Attr)
-    ; '$enqueue_attr_var'(V), '$del_attr_head'(V), '$del_attr'(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)
     ).
 
 '$del_attr_step'(Ls1, V, Attr) :-
-    ( nonvar(Ls1) -> Ls1 = [_ | Ls2], '$del_attr_buried'(Ls1, Ls2, V, Attr)
-    ; true ).
+    (  nonvar(Ls1) -> Ls1 = [_ | Ls2], '$del_attr_buried'(Ls1, Ls2, V, Attr)
+    ;  true ).
 
 %% assumptions: Ls0 is a list, Ls1 is its tail;
 %%              the head of Ls0 can be ignored.
 '$del_attr_buried'(Ls0, Ls1, V, Attr) :-
-    Ls0 = [_, Att | _],
-    nonvar(Att),
-    !,
-    ( Att \= Attr -> '$del_attr_step'(Ls1, V, Attr)
-    ; '$enqueue_attr_var'(V),
-      '$del_attr_non_head'(Ls0), %% set tail of Ls0 = tail of Ls1. can be undone by backtracking.
-      '$del_attr_step'(Ls1, V, Attr)
+    (  var(Ls1) -> true
+    ;  Ls1 = [Att | Ls2] ->
+       (  Att \= Attr -> '$del_attr_buried'(Ls1, Ls2, V, Attr)
+       ;  '$enqueue_attr_var'(V),
+	  '$del_attr_non_head'(Ls0), %% set tail of Ls0 = tail of Ls1. can be undone by backtracking.
+	  '$del_attr_step'(Ls1, V, Attr)
+       )
     ).
-'$del_attr_buried'(_, _, _, _).
 
 '$copy_attr_list'(L, []) :- var(L), !.
 '$copy_attr_list'([Att|Atts], [Att|CopiedAtts]) :-
@@ -125,11 +125,19 @@ put_attr(Name, Arity) -->
     { functor(Attr, Name, Arity),
       numbervars(Attr, 0, Arity),
       V = '$VAR'(Arity) },
-    [(put_atts(V, +Attr) :- !, functor(Attr, Head, Arity), functor(AttrForm, Head, Arity),
-			    '$get_attr_list'(V, Ls), '$del_attr'(Ls, V, AttrForm), '$put_attr'(V, Attr)),
-     (put_atts(V,  Attr) :- !, functor(Attr, Head, Arity), functor(AttrForm, Head, Arity),
-			    '$get_attr_list'(V, Ls), '$del_attr'(Ls, V, AttrForm), '$put_attr'(V, Attr)),
-     (put_atts(V, -Attr) :- !, functor(Attr, _, _), '$get_attr_list'(V, Ls), '$del_attr'(Ls, V, Attr))].
+    [(put_atts(V, +Attr) :- !, functor(Attr, Head, Arity),
+			    functor(AttrForm, Head, Arity),
+			    '$get_attr_list'(V, Ls),
+			    '$del_attr'(Ls, V, AttrForm),
+			    '$put_attr'(V, Attr)),
+     (put_atts(V,  Attr) :- !, functor(Attr, Head, Arity),
+			    functor(AttrForm, Head, Arity),
+			    '$get_attr_list'(V, Ls),
+			    '$del_attr'(Ls, V, AttrForm),
+			    '$put_attr'(V, Attr)),
+     (put_atts(V, -Attr) :- !, functor(Attr, _, _),
+			    '$get_attr_list'(V, Ls),
+			    '$del_attr'(Ls, V, Attr))].
 
 get_attr(Name, Arity) -->
     { functor(Attr, Name, Arity),

src/prolog/lib/between.pl

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

src/prolog/lib/builtins.pl

@@ -1,35 +1,19 @@
 :- op(400, yfx, /).
 
-/* this is an implementation specific declarative operator used to implement call_with_inference_limit/3
-   and setup_call_cleanup/3. switches to the default trust_me and retry_me_else. Indexing choice
-   instructions are unchanged. */
-:- op(700, fx, non_counted_backtracking).
-
-:- module(builtins, [(=)/2, (\=)/2, (\+)/1, (^)/2, (\)/1, (+)/1,
-	(+)/2, (**)/2, (*)/2, (-)/1, (-)/2, (/)/2, (/\)/2, (\/)/2,
-	(is)/2, (xor)/2, (div)/2, (//)/2, (rdiv)/2, (<<)/2, (>>)/2,
-	(mod)/2, (rem)/2, (>)/2, (<)/2, (=\=)/2, (=:=)/2, (>=)/2,
-	(=<)/2, (',')/2, (->)/2, (;)/2, (=..)/2, (==)/2, (\==)/2,
-	(@=<)/2, (@>=)/2, (@<)/2, (@>)/2, (:)/2, 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_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, number_chars/2, number_codes/2,
-	once/1, op/3, read_term/2, repeat/0, retract/1,
-	set_prolog_flag/2, 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]).
-
 % module resolution operator.
 :- op(600, xfy, :).
 
 user:term_expansion((:- op(Pred, Spec, [Op | OtherOps])), OpResults) :-
-    expand_op_list([Op | OtherOps], Pred, Spec, OpResults).
+    '$expand_op_list'([Op | OtherOps], Pred, Spec, OpResults).
 
-expand_op_list([], _, _, []).
-expand_op_list([Op | OtherOps], Pred, Spec, [(:- op(Pred, Spec, Op)) | OtherResults]) :-
-    expand_op_list(OtherOps, Pred, Spec, OtherResults).
+'$expand_op_list'([], _, _, []).
+'$expand_op_list'([Op | OtherOps], Pred, Spec, [(:- op(Pred, Spec, Op)) | OtherResults]) :-
+    '$expand_op_list'(OtherOps, Pred, Spec, OtherResults).
+
+/* this is an implementation specific declarative operator used to implement call_with_inference_limit/3
+   and setup_call_cleanup/3. switches to the default trust_me and retry_me_else. Indexing choice
+   instructions are unchanged. */
+:- op(700, fx, non_counted_backtracking).
 
 % arithmetic operators.
 :- op(700, xfx, is).
@@ -37,8 +21,7 @@ expand_op_list([Op | OtherOps], Pred, Spec, [(:- op(Pred, Spec, Op)) | OtherResu
 :- op(400, yfx, *).
 :- op(200, xfy, [**, ^]).
 :- op(500, yfx, [/\, \/, xor]).
-:- op(400, yfx, [div, //, rdiv]).
-:- op(400, yfx, [<<, >>, mod, rem]).
+:- op(400, yfx, [div, //, rdiv, <<, >>, mod, rem]).
 :- op(200, fy, [+, -, \]).
 
 % arithmetic comparison operators.
@@ -47,9 +30,6 @@ expand_op_list([Op | OtherOps], Pred, Spec, [(:- op(Pred, Spec, Op)) | OtherResu
 % term comparison.
 :- op(700, xfx, [==, \==, @=<, @>=, @<, @>]).
 
-% the maximum arity flag. needs to be replaced with current_prolog_flag(max_arity, MAX_ARITY).
-max_arity(255).
-
 % conditional operators.
 :- op(1050, xfy, ->).
 :- op(1100, xfy, ;).
@@ -58,6 +38,29 @@ max_arity(255).
 :- op(700, xfx, [=, =.., \=]).
 :- op(900, fy, \+).
 
+:- 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,
+                     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]).
+
+
+% the maximum arity flag. needs to be replaced with
+% current_prolog_flag(max_arity, MAX_ARITY).
+max_arity(255).
+
 % unify.
 X = X.
 
@@ -72,6 +75,57 @@ Module : Predicate :-
     ; throw(error(type_error(atom, Module), (:)/2))
     ).
 
+:(Module, Predicate, A1) :-
+    ( atom(Module) -> '$module_call'(A1, Module, Predicate)
+    ; throw(error(type_error(atom, Module), (:)/2))
+    ).
+
+:(Module, Predicate, A1, A2) :-
+    ( atom(Module) -> '$module_call'(A1, A2, Module, Predicate)
+    ; throw(error(type_error(atom, Module), (:)/2))
+    ).
+
+:(Module, Predicate, A1, A2, A3) :-
+    ( atom(Module) -> '$module_call'(A1, A2, A3, Module, Predicate)
+    ; throw(error(type_error(atom, Module), (:)/2))
+    ).
+
+:(Module, Predicate, A1, A2, A3, A4) :-
+    ( atom(Module) -> '$module_call'(A1, A2, A3, A4, Module, Predicate)
+    ; throw(error(type_error(atom, Module), (:)/2))
+    ).
+
+:(Module, Predicate, A1, A2, A3, A4, A5) :-
+    ( atom(Module) -> '$module_call'(A1, A2, A3, A4, A5, Module, Predicate)
+    ; throw(error(type_error(atom, Module), (:)/2))
+    ).
+
+:(Module, Predicate, A1, A2, A3, A4, A5, A6) :-
+    ( atom(Module) -> '$module_call'(A1, A2, A3, A4, A5, A6, Module, Predicate)
+    ; throw(error(type_error(atom, Module), (:)/2))
+    ).
+
+:(Module, Predicate, A1, A2, A3, A4, A5, A6, A7) :-
+    ( atom(Module) -> '$module_call'(A1, A2, A3, A4, A5, A6, A7, Module, Predicate)
+    ; throw(error(type_error(atom, Module), (:)/2))
+    ).
+
+:(Module, Predicate, A1, A2, A3, A4, A5, A6, A7, A8) :-
+    ( atom(Module) -> '$module_call'(A1, A2, A3, A4, A5, A6, A7, A8, Module, Predicate)
+    ; throw(error(type_error(atom, Module), (:)/2))
+    ).
+
+:(Module, Predicate, A1, A2, A3, A4, A5, A6, A7, A8, A9) :-
+    ( atom(Module) -> '$module_call'(A1, A2, A3, A4, A5, A6, A7, A8, A9, Module, Predicate)
+    ; throw(error(type_error(atom, Module), (:)/2))
+    ).
+
+:(Module, Predicate, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) :-
+    ( atom(Module) -> '$module_call'(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Module, Predicate)
+    ; throw(error(type_error(atom, Module), (:)/2))
+    ).
+
+
 % flags.
 
 current_prolog_flag(Flag, false) :- Flag == bounded, !.
@@ -125,13 +179,13 @@ set_prolog_flag(Flag, _) :-
 
 fail :- '$fail'.
 
-\+ G :- G, !, false.
+\+ G :- call(G), !, false.
 \+ _.
 
 X \= X :- !, false.
 _ \= _.
 
-once(G) :- G, !.
+once(G) :- call(G), !.
 
 repeat.
 repeat :- repeat.
@@ -148,12 +202,14 @@ comma_errors(G1, G2, B) :- '$call_with_default_policy'(','(G1, G2, B)).
 		 '$set_cp'(B),
 		 '$call_with_default_policy'(comma_errors(G1, G2, B)).
 ','(!, Atom, B) :- Atom == !, '$set_cp'(B).
-','(!, G, B)  :- '$set_cp'(B), G.
+','(!, G, B)  :- '$set_cp'(B), call(G).
 ','(G, CF, B) :- compound(CF),
-		 '$call_with_default_policy'(CF = ','(G1, G2)), !, G,
+		 '$call_with_default_policy'(CF = ','(G1, G2)),
+		 !,
+		 call(G),
 		 '$call_with_default_policy'(comma_errors(G1, G2, B)).
-','(G, Atom, B) :- Atom == !, !, G, '$set_cp'(B).
-','(G1, G2, _)  :- G1, G2.
+','(G, Atom, B) :- Atom == !, !, call(G), '$set_cp'(B).
+','(G1, G2, _)  :- call(G1), call(G2).
 
 ;(G1, G2) :- '$get_b_value'(B), ;(G1, G2, B).
 
@@ -161,43 +217,56 @@ comma_errors(G1, G2, B) :- '$call_with_default_policy'(','(G1, G2, B)).
 ;(G1, G4, B) :- compound(G1),
 		'$call_with_default_policy'(G1 = ->(G2, G3)),
 		!,
-		(G2 -> G3 ; '$set_cp'(B), G4).
-;(G1, G2, B) :- G1 == !, '$set_cp'(B), G2.
-;(G1, G2, B) :- G2 == !, G1, '$set_cp'(B).
-;(G, _, _) :- G.
-;(_, G, _) :- G.
+		(  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 -> G2 :- '$get_b_value'(B), '$call_with_default_policy'(->(G1, G2, B)).
 
 :- non_counted_backtracking (->)/3.
-->(G1, G2, B) :- G2 == !, G1, '$set_cp'(B).
-->(G1, G2, B) :- G1, '$set_cp'(B), G2.
+->(G1, G2, B) :- G2 == !, call(G1), '$set_cp'(B).
+->(G1, G2, B) :- call(G1), '$set_cp'(B), call(G2).
 
 % univ.
 
 :- non_counted_backtracking univ_errors/3.
 univ_errors(Term, List, N) :-
     '$skip_max_list'(N, -1, List, R),
-    ( var(R)       -> ( var(Term), throw(error(instantiation_error, (=..)/2))      % 8.5.3.3 a)
-		      ; true )
-    ; R \== []     -> throw(error(type_error(list, List), (=..)/2))                % 8.5.3.3 b)
-    ; List = [H|T] -> ( var(H), var(Term), % R == [] => List is a proper list.
-		        throw(error(instantiation_error, (=..)/2))                 % 8.5.3.3 c)
-		      ; T \== [], nonvar(H), \+ atom(H),
-			throw(error(type_error(atom, H), (=..)/2))                 % 8.5.3.3 d)
-		      ; compound(H), T == [],
-			throw(error(type_error(atomic, H), (=..)/2))               % 8.5.3.3 e)
-		      ; var(Term), max_arity(M), N - 1 > M,
-			throw(error(representation_error(max_arity), (=..)/2))     % 8.5.3.3 g)
-		      ; true )
-    ; var(Term)    -> throw(error(domain_error(non_empty_list, List), (=..)/2))    % 8.5.3.3 f)
-    ; true ).
+    ( var(R)        ->
+       (  var(Term), throw(error(instantiation_error, (=..)/2))      % 8.5.3.3 a)
+       ;  true
+       )
+    ;  R \== []     ->
+       throw(error(type_error(list, List), (=..)/2))                % 8.5.3.3 b)
+    ;  List = [H|T] ->
+       (  var(H), var(Term), % R == [] => List is a proper list.
+       	  throw(error(instantiation_error, (=..)/2))                 % 8.5.3.3 c)
+       ;  T \== [], nonvar(H), \+ atom(H),
+       	  throw(error(type_error(atom, H), (=..)/2))                 % 8.5.3.3 d)
+       ;  compound(H), T == [],
+       	  throw(error(type_error(atomic, H), (=..)/2))               % 8.5.3.3 e)
+       ;  var(Term), max_arity(M), N - 1 > M,
+       	  throw(error(representation_error(max_arity), (=..)/2))     % 8.5.3.3 g)
+       ;  true
+       )
+    ;  var(Term)    ->
+       throw(error(domain_error(non_empty_list, List), (=..)/2))    % 8.5.3.3 f)
+    ;  true
+    ).
 
 Term =.. List :- '$call_with_default_policy'(univ_errors(Term, List, N)),
 		 '$call_with_default_policy'(univ_worker(Term, List, N)).
 
+
 :- non_counted_backtracking univ_worker/3.
-univ_worker(Term, List, _) :- atomic(Term), !, '$call_with_default_policy'(List = [Term]).
+
+univ_worker(Term, List, _) :-
+    atomic(Term), !, '$call_with_default_policy'(List = [Term]).
 univ_worker(Term, [Name|Args], N) :-
     var(Term), !,
     '$call_with_default_policy'(Arity is N-1),
@@ -208,7 +277,9 @@ univ_worker(Term, List, _) :-
     '$call_with_default_policy'(get_args(Args, Term, 1, Arity)),
     '$call_with_default_policy'(List = [Name|Args]).
 
+
 :- non_counted_backtracking get_args/4.
+
 get_args(Args, _, _, 0) :-
     !, '$call_with_default_policy'(Args = []).
 get_args([Arg], Func, N, N) :-
@@ -221,17 +292,19 @@ get_args([Arg|Args], Func, I0, 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)
-    ; var(Arg) -> throw(error(instantiation_error, write_term/2))
-    ; throw(error(domain_error(write_option, Functor), write_term/2))
+    (  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
-    ; throw(error(domain_error(write_option, Functor), write_term/2))
+    (  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)
 
 inst_member_or([X|Xs], Y, Z) :-
@@ -273,7 +346,8 @@ write_term(Term, Options) :-
     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([])),
-    '$write_term'(Term, IgnoreOps, NumberVars, Quoted, VarNames).
+    inst_member_or(Options, max_depth(MaxDepth), max_depth(0)),
+    '$write_term'(Term, IgnoreOps, NumberVars, Quoted, VarNames, MaxDepth).
 
 write(Term) :- write_term(Term, [numbervars(true)]).
 
@@ -318,7 +392,8 @@ catch(G,C,R) :- '$get_current_block'(Bb), '$call_with_default_policy'(catch(G,C,
 
 :- non_counted_backtracking catch/4.
 catch(G,C,R,Bb) :-
-    '$install_new_block'(NBb), call(G),
+    '$install_new_block'(NBb),
+    call(G),
     '$call_with_default_policy'(end_block(Bb, NBb)).
 catch(G,C,R,Bb) :-
     '$reset_block'(Bb),
@@ -382,7 +457,7 @@ set_difference([], _, []) :- !.
 set_difference(Xs, [], Xs).
 
 group_by_variant([V2-S2 | Pairs], V1-S1, [S2 | Solutions], Pairs0) :-
-    non_iso:variant(V1, V2), !, V1 = V2, group_by_variant(Pairs, V2-S2, Solutions, Pairs0).
+    iso_ext:variant(V1, V2), !, V1 = V2, group_by_variant(Pairs, V2-S2, Solutions, Pairs0).
 group_by_variant(Pairs, _, [], Pairs).
 
 group_by_variants([V-S|Pairs], [V-Solution|Solutions]) :-
@@ -390,7 +465,10 @@ group_by_variants([V-S|Pairs], [V-Solution|Solutions]) :-
     group_by_variants(Pairs0, Solutions).
 group_by_variants([], []).
 
-iterate_variants([V-Solution|GroupSolutions], V, Solution).
+iterate_variants([V-Solution|GroupSolutions], V, Solution) :-
+    (  GroupSolutions == [] -> !
+    ;  true
+    ).
 iterate_variants([_|GroupSolutions], Ws, Solution) :-
     iterate_variants(GroupSolutions, Ws, Solution).
 
@@ -406,7 +484,9 @@ findall_with_existential(Template, Goal, PairedSolutions, Witnesses0, Witnesses)
     (  nonvar(Goal), Goal = _ ^ _ ->
        rightmost_power(Goal, Goal1, ExistentialVars0),
        term_variables(ExistentialVars0, ExistentialVars),
-       set_difference(Witnesses0, ExistentialVars, Witnesses),
+       sort(Witnesses0, Witnesses1),
+       sort(ExistentialVars, ExistentialVars1),
+       set_difference(Witnesses1, ExistentialVars1, Witnesses),
        findall(Witnesses-Template, Goal1, PairedSolutions)
     ;  Witnesses = Witnesses0,
        findall(Witnesses-Template, Goal, PairedSolutions)
@@ -425,7 +505,10 @@ bagof(Template, Goal, Solution) :-
     iterate_variants(GroupedSolutions, Witnesses, Solution).
 
 iterate_variants_and_sort([V-Solution0|GroupSolutions], V, Solution) :-
-    sort(Solution0, Solution).
+    sort(Solution0, Solution),
+    (  GroupSolutions == [] -> !
+    ;  true
+    ).
 iterate_variants_and_sort([_|GroupSolutions], Ws, Solution) :-
     iterate_variants_and_sort(GroupSolutions, Ws, Solution).
 
@@ -548,9 +631,11 @@ assertz_clause(Head, Body) :-
 	 arg(1, Head, Module),
 	 arg(2, Head, F),
 	 module_assertz_clause(F, Body, Module)
-       ; '$no_such_predicate'(Head) -> call_assertz(Head, Body, Name, Arity)
-       ; '$head_is_dynamic'(Head) -> call_assertz(Head, Body, Name, Arity)
-       ;  throw(error(permission_error(modify, static_procedure, Name/Arity), assertz/1))
+       ; '$no_such_predicate'(Head) ->
+	 call_assertz(Head, Body, Name, Arity)
+       ; '$head_is_dynamic'(Head) ->
+	 call_assertz(Head, Body, Name, Arity)
+       ; throw(error(permission_error(modify, static_procedure, Name/Arity), assertz/1))
        )
     ;  throw(error(type_error(callable, Head), assertz/1))
     ).
@@ -561,12 +646,13 @@ assertz(Clause) :-
     ).
 
 first_match_index([Clause0 | Clauses], Clause1, N0, N) :-
-    (  Clause0 \= Clause1 -> N1 is N0 + 1,
-			     first_match_index(Clauses, Clause1, N1, N)
+    (  Clause0 \= Clause1 ->
+       N1 is N0 + 1,
+       first_match_index(Clauses, Clause1, N1, N)
     ;  N0 = N, Clause0 = Clause1
     ).
 
-retract_clauses([Clause|Clauses0], Head, Body, Name, Arity) :-
+retract_clauses([Clause | Clauses0], Head, Body, Name, Arity) :-
     functor(VarHead, Name, Arity),
     findall((VarHead :- VarBody), clause(VarHead, VarBody), Clauses1),
     first_match_index(Clauses1, (Head :- Body), 0, N),
@@ -574,7 +660,7 @@ retract_clauses([Clause|Clauses0], Head, Body, Name, Arity) :-
     ;  true
     ),
     '$retract_clause'(Name, Arity, N, Clauses1).
-retract_clauses([_|Clauses0], Head, Body, Name, Arity) :-
+retract_clauses([_ | Clauses0], Head, Body, Name, Arity) :-
     retract_clauses(Clauses0, Head, Body, Name, Arity).
 
 call_retract(Head, Body, Name, Arity) :-
@@ -859,8 +945,12 @@ 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) :- chars_or_vars(Cs, 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) :-
@@ -874,8 +964,12 @@ chars_or_vars([C|Cs], PI) :-
     ;  chars_or_vars(Cs, PI)
     ).
 
-can_be_codes_or_vars(Cs, _) :- var(Cs), !.
-can_be_codes_or_vars(Cs, PI) :- codes_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) :-
@@ -929,3 +1023,19 @@ subsumes_term(General, Specific) :-
    ).
 
 unify_with_occurs_check(X, Y) :- '$unify_with_occurs_check'(X, Y).
+
+current_input(S) :- '$current_input'(S).
+
+current_output(S) :- '$current_output'(S).
+
+set_input(S) :-
+    (  var(S) ->
+       throw(error(instantiation_error, set_input/1))
+    ;  '$set_input'(S)
+    ).
+
+set_output(S) :-
+    (  var(S) ->
+       throw(error(instantiation_error, set_output/1))
+    ;  '$set_output'(S)
+    ).

src/prolog/lib/charsio.pl

@@ -0,0 +1,39 @@
+:- module(charsio, [read_term_from_chars/2,
+                    write_term_to_chars/3]).
+
+:- use_module(library(iso_ext)).
+
+read_term_from_chars(Chars, Term) :-
+    (  var(Chars) ->
+       throw(error(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
+    ;
+       throw(error(type_error(complete_string, Chars), read_term_from_chars/2))
+    ),
+    '$read_term_from_chars'(Chars, Term).
+
+
+write_term_to_chars(_, Options, _) :-
+    var(Options), throw(error(instantiation_error, write_term_to_chars/3)).
+write_term_to_chars(Term, Options, Chars) :-
+    '$skip_max_list'(_, -1, Options, Options0),
+    (  var(Options0)  ->
+       throw(error(instantiation_error, write_term_to_chars/3))
+    ;  nonvar(Chars)  ->
+       throw(error(uninstantiation_error(Chars), write_term_to_chars/3))
+    ;  Options0 == [] ->
+       true
+    ;
+       throw(error(type_error(list, Options), write_term_to_chars/3))
+    ),
+    builtins:inst_member_or(Options, ignore_ops(IgnoreOps), ignore_ops(false)),
+    builtins:inst_member_or(Options, numbervars(NumberVars), numbervars(false)),
+    builtins:inst_member_or(Options, quoted(Quoted), quoted(false)),
+    builtins:inst_member_or(Options, variable_names(VarNames), variable_names([])),
+    builtins:inst_member_or(Options, max_depth(MaxDepth), max_depth(0)),
+    '$write_term_to_chars'(Term, IgnoreOps, NumberVars, Quoted, VarNames, MaxDepth, Chars).

src/prolog/lib/clpb.pl

@@ -16,11 +16,9 @@
    Public operators.
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
-:- op(300, fy, ~).
-:- op(500, yfx, #).
-
-:- module(clpb, [
-                 sat/1,
+:- module(clpb, [op(300, fy, ~),
+		 op(500, yfx, #),
+		 sat/1,
                  taut/2,
                  labeling/1,
                  sat_count/2,
@@ -32,9 +30,10 @@
 :- use_module(library(between)).
 :- use_module(library(atts)).
 :- use_module(library(lists)).
-:- use_module(library(non_iso)).
+:- use_module(library(iso_ext)).
+:- use_module(library(pairs)).
 :- use_module(library(dcgs)).
-%:- use_module(library(types)).
+:- use_module(library(error), []).
 
 :- attribute
         clpb/1,
@@ -77,8 +76,8 @@ must_be(list(What), Where, Term) :- !,
 must_be(ground, _, Term) :- !,
         functor(Term, _, _).
 
-must_be(Type, Goal-Arg, Term) :-
-        must_be(Term, Type, Goal, Arg).
+must_be(Type, _, Term) :-
+        error:must_be(Type, Term).
 
 clpz_list(Nil, _) :- Nil == [].
 clpz_list(Ls, Where) :-
@@ -87,7 +86,6 @@ clpz_list(Ls, Where) :-
     ;   Ls = [_|Rest],
         clpz_list(Rest, Where)
     ).
-    
 
 
 instantiation_error(Term) :- instantiation_error(Term, unknown(Term)-1).
@@ -109,62 +107,10 @@ type_error(Expectation, Term) :-
 type_error(Expectation, Term, Goal-Arg) :-
         throw(error(type_error(Expectation, Term), type_error(Goal, Arg, Expectation, Term))).
 
-
-/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-   foldl/4
-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
-
-foldl(Goal_3, Ls, A0, A) :-
-        foldl_(Ls, Goal_3, A0, A).
-
-foldl_([], _, A, A).
-foldl_([L|Ls], G_3, A0, A) :-
-        call(G_3, L, A0, A1),
-        foldl_(Ls, G_3, A1, A).
-
-/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-   foldl/5
-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
-
-foldl(Goal_4, Xs, Ys, A0, A) :-
-        foldl_(Xs, Ys, Goal_4, A0, A).
-
-foldl_([], [], _, A, A).
-foldl_([X|Xs], [Y|Ys], G_4, A0, A) :-
-        call(G_4, X, Y, A0, A1),
-        foldl_(Xs, Ys, G_4, A1, A).
-
-
 partition(Pred, Ls0, As, Bs) :-
         include(Pred, Ls0, As),
         exclude(Pred, Ls0, Bs).
 
-sum_list(Ls, S) :- sumlist(Ls, S).
-
-/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  Pairs.
-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
-
-pairs_keys_values([], [], []).
-pairs_keys_values([A-B|ABs], [A|As], [B|Bs]) :-
-        pairs_keys_values(ABs, As, Bs).
-
-pairs_keys(Ps, Ks) :- pairs_keys_values(Ps, Ks, _).
-
-pairs_values(Ps, Vs) :- pairs_keys_values(Ps, _, Vs).
-
-map_list_to_pairs(Pred, Ls, Ps) :-
-        map_list_to_pairs2(Ls, Pred, Ps).
-
-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).
-
-
-
-
-
 goal_expansion(get_attr(Var, Module, Value), (var(Var),get_atts(Var, Access))) :-
         Access =.. [Module,Value].
 
@@ -728,10 +674,6 @@ existential(V, BDD, Node) :-
    Counter network for card(Is,Fs).
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
-same_length([], []).
-same_length([_|As], [_|Bs]) :-
-        same_length(As, Bs).
-
 counter_network(Cs, Fs, Node) :-
         same_length([_|Fs], Indicators),
         fill_indicators(Indicators, 0, Cs),
@@ -1242,8 +1184,7 @@ bdd_count(Node, VNum, Count) :-
                 bdd_count(High, VNum, HCount),
                 bdd_pow(Low, V, VNum, LPow),
                 bdd_pow(High, V, VNum, HPow),
-                Count0 is LPow*LCount + HPow*HCount,
-                Count = Count0
+                Count is LPow*LCount + HPow*HCount
             )
         ).
 

src/prolog/lib/cont.pl

@@ -0,0 +1,30 @@
+:- module(cont, [reset/3, shift/1]).
+
+reset(Goal, Ball, Cont) :-
+    call(Goal),
+    '$reset_cont_marker',
+    '$bind_from_register'(Cont, 3),
+    '$bind_from_register'(Ball, 4).
+
+shift(Ball) :-
+    '$nextEP'(first, E, P),
+    get_chunks(E, P, L),
+    (  L == [] ->
+       Cont = none
+    ;  Cont = cont(call_continuation(L))
+    ),
+    '$write_cont_and_term'(_, _, Cont, Ball),
+    '$unwind_environments'.
+
+get_chunks(E, P, L) :-
+    (  '$points_to_cont_reset_marker'(P) ->
+       L = []
+    ;  '$get_cont_chunk'(E,P,TB),
+       L = [TB|Rest],
+       '$nextEP'(E, NextE, NextP),
+       get_chunks(NextE, NextP, Rest)
+    ).
+
+call_continuation(L) :- '$call_continuation'(L).
+
+'$write_cont_and_term'(_, _, _, _).

src/prolog/lib/dcgs.pl

@@ -1,12 +1,14 @@
-:- op(1200, xfx, -->).
-% :- op(1105, xfy, ('|')).
-
-:- module(dcgs, [phrase/2, phrase/3]).
+:- module(dcgs, [op(1200, xfx, -->),
+		 op(1105, xfy, '|'),
+		 phrase/2,
+		 phrase/3]).
 
+:- use_module(library(error)).
 :- use_module(library(lists), [append/3]).
 
-user:term_expansion(Term0, (Head :- Body)) :-
-    dcg_rule(Term0, Term),
+user:term_expansion(Term0, Term) :-
+    nonvar(Term0),
+    dcg_rule(Term0, (Head :- Body)),
     Term = (Head :- Body).
 
 phrase(GRBody, S0) :-
@@ -31,10 +33,10 @@ phrase_((A -> B ; C), S0, S) :-
     ).
 phrase_((A ; B), S0, S) :-
     (  phrase(A, S0, S) ; phrase(B, S0, S)  ).
-%% phrase_((A | B), S0, S) :-
-%%     (  phrase(A, S0, S) ; phrase(B, S0, S)  ).
+phrase_((A | B), S0, S) :-
+    (  phrase(A, S0, S) ; phrase(B, S0, S)  ).
 phrase_({G}, S0, S) :-
-    (  G, S0 = S  ).
+    (  call(G), S0 = S  ).
 phrase_(call(G), S0, S) :-
     call(G, S0, S).
 phrase_((A -> B), S0, S) :-
@@ -44,6 +46,17 @@ phrase_(phrase(NonTerminal), S0, S) :-
 phrase_([T|Ts], S0, S) :-
     append([T|Ts], S, S0).
 
+% The same version of the below two dcg_rule clauses, but with module scoping.
+dcg_rule(( M:NonTerminal, Terminals --> GRBody ), ( M:Head :- Body )) :-
+    dcg_non_terminal(NonTerminal, S0, S, Head),
+    dcg_body(GRBody, S0, S1, Goal1),
+    dcg_terminals(Terminals, S, S1, Goal2),
+    Body = ( Goal1, Goal2 ).
+dcg_rule(( M:NonTerminal --> GRBody ), ( M:Head :- Body )) :-
+    NonTerminal \= ( _, _ ),
+    dcg_non_terminal(NonTerminal, S0, S, Head),
+    dcg_body(GRBody, S0, S, Body).
+
 % This program uses append/3 as defined in the Prolog prologue.
 % Expands a DCG rule into a Prolog rule, when no error condition applies.
 dcg_rule(( NonTerminal, Terminals --> GRBody ), ( Head :- Body )) :-
@@ -84,7 +97,7 @@ dcg_constr([]). % 7.14.1
 dcg_constr([_|_]). % 7.14.2 - terminal sequence
 dcg_constr(( _, _ )). % 7.14.3 - concatenation
 dcg_constr(( _ ; _ )). % 7.14.4 - alternative
-%% dcg_constr(( _'|'_ )). % 7.14.6 - alternative
+dcg_constr(( _'|'_ )). % 7.14.6 - alternative
 dcg_constr({_}). % 7.14.7
 dcg_constr(call(_)). % 7.14.8
 dcg_constr(phrase(_)). % 7.14.9
@@ -96,6 +109,7 @@ dcg_constr((_->_)). % 7.14.12 - if-then (existence implementation dep.)
 % the construct to be expanded.
 dcg_cbody([], S0, S, S0 = S).
 dcg_cbody([T|Ts], S0, S, Goal) :-
+    must_be(list, [T|Ts]),
     dcg_terminals([T|Ts], S0, S, Goal).
 dcg_cbody(( GRFirst, GRSecond ), S0, S, ( First, Second )) :-
     dcg_body(GRFirst, S0, S1, First),
@@ -108,9 +122,9 @@ dcg_cbody(( GRCond ; GRElse ), S0, S, ( Cond ; Else )) :-
     subsumes_term(( _GRIf -> _GRThen ), GRCond),
     dcg_cbody(GRCond, S0, S, Cond),
     dcg_body(GRElse, S0, S, Else).
-%% dcg_cbody(( GREither '|' GROr ), S0, S, ( Either ; Or )) :-
-%%     dcg_body(GREither, S0, S, Either),
-%%     dcg_body(GROr, S0, S, Or).
+dcg_cbody(( GREither '|' GROr ), S0, S, ( Either ; Or )) :-
+    dcg_body(GREither, S0, S, Either),
+    dcg_body(GROr, S0, S, Or).
 dcg_cbody({Goal}, S0, S, ( Goal, S0 = S )).
 dcg_cbody(call(Cont), S0, S, call(Cont, S0, S)).
 dcg_cbody(phrase(Body), S0, S, phrase(Body, S0, S)).

src/prolog/lib/dif.pl

@@ -51,4 +51,5 @@ gather_dif_goals([(X \== Y) | Goals]) -->
 
 attribute_goals(X) -->
     { get_atts(X, +dif(Goals)) },
-    gather_dif_goals(Goals).
+    gather_dif_goals(Goals),
+    { put_atts(X, -dif(_)) }.

src/prolog/lib/error.pl

@@ -33,6 +33,10 @@ must_be(Type, Term) :-
 must_be_(Type, _) :-
         var(Type),
         instantiation_error(Type).
+must_be_(var, Term) :-
+        (   var(Term) -> true
+        ;   throw(error(uninstantiation_error, _))
+        ).
 must_be_(integer, Term) :- check_(integer, integer, Term).
 must_be_(atom, Term)    :- check_(atom, atom, Term).
 must_be_(list, Term)    :- check_(ilist, list, Term).
@@ -52,6 +56,7 @@ type(type).
 type(integer).
 type(atom).
 type(list).
+type(var).
 
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    can_be(Type, Term)

src/prolog/lib/format.pl

@@ -0,0 +1,481 @@
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Written March 2020 by Markus Triska (triska@metalevel.at)
+   Part of Scryer Prolog.
+
+   This library provides the nonterminal format_//2 to describe
+   formatted strings. format/2 is provided for impure output.
+
+   Usage:
+   ======
+
+   phrase(format_(FormatString, Arguments), Ls)
+
+   format_//2 describes a list of characters Ls that are formatted
+   according to FormatString. FormatString is a string (i.e.,
+   a list of characters) that specifies the layout of Ls.
+   The characters in FormatString are used literally, except
+   for the following tokens with special meaning:
+
+     ~w    use the next available argument from Arguments here
+     ~q    use the next argument here, formatted as by writeq/1
+     ~a    use the next argument here, which must be an atom
+     ~s    use the next argument here, which must be a string
+     ~d    use the next argument here, which must be an integer
+     ~f    use the next argument here, a floating point number
+     ~Nf   where N is an integer: format the float argument
+           using N digits after the decimal point
+     ~Nd   like ~d, placing the last N digits after a decimal point;
+           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)
+     ~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)
+     ~t    distribute spaces evenly between the two closest tab stops
+     ~`Ct  like ~t, use character C instead of spaces to fill the space
+     ~n    newline
+     ~Nn   N newlines
+     ~i    ignore the next argument
+     ~~    the literal ~
+
+   Instead of ~N, you can write ~* to use the next argument from Arguments
+   as the numeric argument.
+
+   The predicate format/2 is like format_//2, except that it outputs
+   the text on the terminal instead of describing it declaratively.
+
+   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).
+
+   The entire library only works if the Prolog flag double_quotes
+   is set to chars, the default value in Scryer Prolog. This should
+   also stay that way, to encourage a sensible environment.
+
+   Example:
+
+   ?- phrase(format_("~s~n~`.t~w!~12|", ["hello",there]), Cs).
+   %@    Cs = [h,e,l,l,o,'\n','.','.','.','.','.','.',t,h,e,r,e,!]
+   %@ ;  false.
+
+   I place this code in the public domain. Use it in any way you want.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+:- module(format, [format_//2,
+                   format/2,
+                   portray_clause/1
+                  ]).
+
+:- use_module(library(dcgs)).
+:- use_module(library(lists)).
+:- use_module(library(error)).
+:- use_module(library(charsio)).
+
+format_(Fs, Args) -->
+        { must_be(list, Fs),
+          must_be(list, Args),
+          phrase(cells(Fs,Args,0,[]), Cells) },
+        format_cells(Cells).
+
+format_cells([]) --> [].
+format_cells([Cell|Cells]) -->
+        format_cell(Cell),
+        format_cells(Cells).
+
+format_cell(newline) --> "\n".
+format_cell(cell(From,To,Es)) -->
+        % distribute the space between the glue elements
+        { phrase(elements_gluevars(Es, 0, Length), Vs),
+          (   Vs = [] -> true
+          ;   Space is To - From - Length,
+              (   Space =< 0 -> maplist(=(0), Vs)
+              ;   length(Vs, NumGlue),
+                  Distr is Space // NumGlue,
+                  Delta is Space - Distr*NumGlue,
+                  (   Delta =:= 0 ->
+                      maplist(=(Distr), Vs)
+                  ;   BigGlue is Distr + Delta,
+                      reverse(Vs, [BigGlue|Rest]),
+                      maplist(=(Distr), Rest)
+                  )
+              )
+          ) },
+        format_elements(Es).
+
+format_elements([]) --> [].
+format_elements([E|Es]) -->
+        format_element(E),
+        format_elements(Es).
+
+format_element(chars(Cs)) --> list(Cs).
+format_element(glue(Fill,Num)) -->
+        { length(Ls, Num),
+          maplist(=(Fill), Ls) },
+        list(Ls).
+
+list([]) --> [].
+list([L|Ls]) --> [L], list(Ls).
+
+elements_gluevars([], N, N) --> [].
+elements_gluevars([E|Es], N0, N) -->
+        element_gluevar(E, N0, N1),
+        elements_gluevars(Es, N1, N).
+
+element_gluevar(chars(Cs), N0, N) -->
+        { length(Cs, L),
+          N is N0 + L }.
+element_gluevar(glue(_,V), N, N) --> [V].
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Our key datastructure is a list of cells and newlines.
+   A cell has the shape from_to(From,To,Elements), where
+   From and To denote the positions of surrounding tab stops.
+
+   Elements is a list of elements that occur in a cell,
+   namely terms of the form chars(Cs) and glue(Char, Var).
+   "glue" elements (TeX terminology) are evenly stretched
+   to fill the remaining whitespace in the cell. For each
+   glue element, the character Char is used for filling,
+   and Var is a free variable that is used when the
+   available space is distributed.
+
+   newline is used if ~n occurs in a format string.
+   It is is used because a newline character does not
+   consume whitespace in the sense of format strings.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+cells([], Args, Tab, Es) -->
+        (   { Args == [] } -> cell(Tab, Tab, Es)
+        ;   { domain_error(no_remaining_arguments, Args) }
+        ).
+cells([~,~|Fs], Args, Tab, Es) --> !,
+        cells(Fs, Args, Tab, [chars("~")|Es]).
+cells([~,w|Fs], [Arg|Args], Tab, Es) --> !,
+        { write_term_to_chars(Arg, [], Chars) },
+        cells(Fs, Args, Tab, [chars(Chars)|Es]).
+cells([~,q|Fs], [Arg|Args], Tab, Es) --> !,
+        { write_term_to_chars(Arg, [quoted(true)], Chars) },
+        cells(Fs, Args, Tab, [chars(Chars)|Es]).
+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]) },
+        !,
+        { number_chars(Arg, Cs0) },
+        (   { Num =:= 0 } -> { Cs = Cs0 }
+        ;   { length(Cs0, L),
+              (   L =< Num ->
+                  Delta is Num - L,
+                  length(Zs, Delta),
+                  maplist(=('0'), Zs),
+                  phrase(("0.",list(Zs),list(Cs0)), Cs)
+              ;   BeforeComma is L - Num,
+                  length(Bs, BeforeComma),
+                  append(Bs, Ds, Cs0),
+                  phrase((list(Bs),".",list(Ds)), Cs)
+              ) }
+        ),
+        cells(Fs, Args, Tab, [chars(Cs)|Es]).
+cells([~|Fs0], Args0, Tab, Es) -->
+        { numeric_argument(Fs0, Num, ['D'|Fs], Args0, [Arg|Args]) },
+        !,
+        { number_chars(Num, NCs),
+          phrase(("~",list(NCs),"d"), FStr),
+          phrase(format_(FStr, [Arg]), Cs0),
+          phrase(upto_what(Bs0, .), Cs0, Ds),
+          reverse(Bs0, Bs1),
+          phrase(groups_of_three(Bs1), Bs2),
+          reverse(Bs2, Bs),
+          append(Bs, Ds, Cs) },
+        cells(Fs, Args, Tab, [chars(Cs)|Es]).
+cells([~,i|Fs], [_|Args], Tab, Es) --> !,
+        cells(Fs, Args, Tab, Es).
+cells([~,n|Fs], Args, Tab, Es) --> !,
+        cell(Tab, Tab, Es),
+        n_newlines(1),
+        cells(Fs, Args, 0, []).
+cells([~|Fs0], Args0, Tab, Es) -->
+        { numeric_argument(Fs0, Num, [n|Fs], Args0, Args) },
+        !,
+        cell(Tab, Tab, Es),
+        n_newlines(Num),
+        cells(Fs, Args, 0, []).
+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) },
+        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),
+          phrase(upto_what(Bs, .), Cs0, Cs),
+          (   Num =:= 0 -> Chars = Bs
+          ;   (   Cs = ['.'|Rest] ->
+                  length(Rest, L),
+                  (   Num < L ->
+                      length(Ds, Num),
+                      append(Ds, _, Rest)
+                  ;   Num =:= L ->
+                      Ds = Rest
+                  ;   Num > L,
+                      Delta is Num - L,
+                      % we should look into the float with
+                      % greater accuracy here, and use the
+                      % actual digits instead of 0.
+                      length(Zs, Delta),
+                      maplist(=('0'), Zs),
+                      append(Rest, Zs, Ds)
+                  )
+              ;   length(Ds, Num),
+                  maplist(=('0'), Ds)
+              ),
+              append(Bs, ['.'|Ds], Chars)
+          ) },
+        cells(Fs, Args, Tab, [chars(Chars)|Es]).
+cells([~,'`',Char,t|Fs], Args, Tab, Es) --> !,
+        cells(Fs, Args, Tab, [glue(Char,_)|Es]).
+cells([~,t|Fs], Args, Tab, Es) --> !,
+        cells(Fs, Args, Tab, [glue(' ',_)|Es]).
+cells([~|Fs0], Args0, Tab, Es) -->
+        { numeric_argument(Fs0, Num, ['|'|Fs], Args0, Args) },
+        !,
+        cell(Tab, Num, Es),
+        cells(Fs, Args, Num, []).
+cells([~|Fs0], Args0, Tab0, Es) -->
+        { numeric_argument(Fs0, Num, [+|Fs], Args0, Args) },
+        !,
+        { Tab is Tab0 + Num },
+        cell(Tab0, Tab, Es),
+        cells(Fs, Args, Tab, []).
+cells([~,C|_], _, _, _) -->
+        { atom_chars(A, [~,C]),
+          domain_error(format_string, A) }.
+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), _)).
+
+n_newlines(0) --> !.
+n_newlines(1) --> !, [newline].
+n_newlines(N0) --> { N0 > 1, N is N0 - 1 }, [newline], n_newlines(N).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+?- phrase(upto_what(Cs, ~), "abc~test", Rest).
+Cs = [a,b,c], Rest = [~,t,e,s,t].
+?- phrase(upto_what(Cs, ~), "abc", Rest).
+Cs = [a,b,c], Rest = [].
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+upto_what([], W), [W] --> [W], !.
+upto_what([C|Cs], W) --> [C], !, upto_what(Cs, W).
+upto_what([], _) --> [].
+
+groups_of_three([A,B,C,D|Rs]) --> !, [A,B,C], ",", groups_of_three([D|Rs]).
+groups_of_three(Ls) --> list(Ls).
+
+cell(From, To, Es0) -->
+        (   { Es0 == [] } -> []
+        ;   { reverse(Es0, Es) },
+            [cell(From,To,Es)]
+        ).
+
+%?- numeric_argument("2f", Num, ['f'|Fs], Args0, Args).
+
+%?- numeric_argument("100b", Num, Rs, Args0, Args).
+
+numeric_argument(Ds, Num, Rest, Args0, Args) :-
+        (   Ds = [*|Rest] ->
+            Args0 = [Num|Args]
+        ;   numeric_argument_(Ds, [], Ns, Rest),
+            foldl(pow10, Ns, 0-0, Num-_),
+            Args0 = Args
+        ).
+
+numeric_argument_([D|Ds], Ns0, Ns, Rest) :-
+        (   member(D, "0123456789") ->
+            number_chars(N, [D]),
+            numeric_argument_(Ds, [N|Ns0], Ns, Rest)
+        ;   Ns = Ns0,
+            Rest = [D|Ds]
+        ).
+
+
+pow10(D, N0-Pow0, N-Pow) :-
+        N is N0 + D*10^Pow0,
+        Pow is Pow0 + 1.
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   Impure I/O, implemented as a small wrapper over format_//2.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+format(Fs, Args) :-
+        phrase(format_(Fs, Args), Cs),
+        maplist(write, Cs).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+?- phrase(cells("hello", [], 0, []), Cs).
+
+?- phrase(cells("hello~10|", [], 0, []), Cs).
+?- phrase(cells("~ta~t~10|", [], 0, []), Cs).
+
+?- phrase(format_("~`at~50|", []), Ls).
+
+?- phrase(cells("~`at~50|", [], 0, []), Cs),
+   phrase(format_cells(Cs), Ls).
+?- phrase(cells("~ta~t~tb~tc~21|", [], 0, []), Cs).
+Cs = [cell(0,21,[glue(' ',_38),chars([a]),glue(' ',_62),glue(' ',_67),chars([b]),glue(' ',_91),chars([c])])].
+?- phrase(cells("~ta~t~4|", [], 0, []), Cs).
+Cs = [cell(0,4,[glue(' ',_38),chars([a]),glue(' ',_62)])].
+
+?- phrase(format_cell(cell(0,1,[glue(a,_94)])), Ls).
+
+?- phrase(format_cell(cell(0,50,[chars("hello")])), Ls).
+
+?- phrase(format_("~`at~50|~n", []), Ls).
+?- phrase(format_("hello~n~tthere~6|", []), Ls).
+
+?- format("~ta~t~4|", []).
+    a  true
+;  false.
+
+?- format("~ta~tb~tc~10|", []).
+     a  b   ctrue
+;  false.
+
+?- format("~tabc~3|", []).
+
+?- format("~ta~t~4|", []).
+
+?- format("~ta~t~tb~tc~20|", []).
+       a        b     ctrue
+;  false.
+
+?- format("~2f~n", [3]).
+   3.00
+true
+
+?- format("~20f", [0.1]).
+   0.10000000000000000000true % this should use higher accuracy!
+;  false.
+
+?- X is atan(2), format("~7f~n", [X]).
+   1.1071487
+X = 1.1071487177940906
+
+?- format("~`at~50|~n", []).
+   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+true
+
+?- format("~t~N", []).
+
+?- format("~q", [.]).
+   '.'true
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   We also provide a rudimentary version of portray_clause/1.
+
+   In the eventual library organization, portray_clause/1
+   and related predicates (such as listing/1) 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) :-
+        phrase(portray_clause_(Term), Ls),
+        maplist(write, Ls).
+
+portray_clause_(Term) -->
+        portray_(Term), ".\n".
+
+literal(Lit) --> format_("~q", [Lit]).
+
+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).
+
+
+body_(Var, C, I) --> { 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 )
+        { 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) --> !,
+        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).
+
+
+else_branch(Else, C, I) -->
+        indent_to(0, I),
+        ";", "  ", % (see #336)
+        body_(Else, C, C), "\n",
+        indent_to(0, I),
+        ")".
+
+indent_to(CurrentColumn, Indent) -->
+        { Delta is Indent - CurrentColumn },
+        format_("~t~*|", [Delta]).
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+?- portray_clause(a), nl.
+   a.
+
+?- nl, portray_clause((a :- b)), nl.
+a :-
+        b.
+
+?- nl, portray_clause((a :- b, c, d)), nl.
+a :-
+        b,
+        c,
+        d.
+
+
+?- nl, portray_clause([a,b,c,d]), nl.
+"abcd".
+
+?- nl, portray_clause(X).
+?- nl, portray_clause((f(X) :- X)).
+
+?- nl, portray_clause((h :- ( a -> b; c))).
+
+?- nl, portray_clause((h :- ( (a -> x ; y) -> b; c))).
+
+?- nl, portray_clause((h(X) :- ( (a(X) ; y(A,B)) -> b; c))).
+
+?- nl, portray_clause((h :- (a,d;b,c) ; (b,e;d))).
+
+?- nl, portray_clause((a :- b ; c ; d)).
+
+?- nl, portray_clause((h :- L = '.')).
+
+?- nl, portray_clause(-->(a, (b, {t}, d))).
+
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

src/prolog/lib/freeze.pl

@@ -21,15 +21,8 @@ freeze(X, Goal) :-
     put_atts(Fresh, frozen(Goal)),
     Fresh = X.
 
-gather_freeze_goals(Attrs, _) -->
-    { var(Attrs) },
-    !.
-gather_freeze_goals([frozen(X) | _], Var) -->
-    [freeze(Var, X)],
-    !.
-gather_freeze_goals([_ | Attrs], Var) -->
-    gather_freeze_goals(Attrs, Var).
+attribute_goals(Var) -->
+    { get_atts(Var, frozen(Goals)),
+      put_atts(Var, -frozen(_)) },
+    [freeze(Var, Goals)].
 
-attribute_goals(X) -->
-    { '$get_attr_list'(X, Attrs) },
-    gather_freeze_goals(Attrs, X).

src/prolog/lib/gensym.pl

@@ -0,0 +1,32 @@
+:- module(gensym, [gensym/2,
+		   reset_gensym/1]).
+
+:- use_module(library(error)).
+:- use_module(library(lists)).
+:- use_module(library(iso_ext)).
+:- use_module(library(si)).
+
+gensym_key(Base, BaseKey) :-
+    atom_concat('gensym_', Base, BaseKey).
+
+append_id(Base, UniqueID, Unique) :-
+    atom_chars(Base, BaseChars),
+    number_chars(UniqueID, IDChars),
+    append(BaseChars, IDChars, AtomChars),
+    atom_chars(Unique, AtomChars).
+
+gensym(Base, Unique) :-
+    must_be(var, Unique),
+    atom_si(Base),
+    gensym_key(Base, BaseKey),
+    (  bb_get(BaseKey, UniqueID0) ->
+       UniqueID is UniqueID0 + 1,
+       bb_put(BaseKey, UniqueID),
+       append_id(Base, UniqueID, Unique)
+    ;  bb_put(BaseKey, 1),
+       append_id(Base, 1, Unique)
+    ).
+
+reset_gensym(Base) :-
+    atom_si(Base),
+    bb_put(Base, 0).

src/prolog/lib/iso_ext.pl

@@ -1,11 +1,13 @@
 %% for builtins that are not part of the ISO standard.
 %% must be loaded at the REPL with
 
-%% ?- use_module(library(non_iso)).
+%% ?- use_module(library(iso_ext)).
 
-:- module(non_iso, [bb_b_put/2, bb_get/2, bb_put/2, call_cleanup/2,
-		    call_with_inference_limit/3, forall/2,
-		    setup_call_cleanup/3, variant/2]).
+:- 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]).
 
 forall(Generate, Test) :-
     \+ (Generate, \+ Test).
@@ -21,7 +23,7 @@ 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))
-    ;  call_cleanup((store_global_var(Key, NewValue, _) ; false),
+    ;  call_cleanup((store_global_var_with_offset(Key, NewValue) ; false),
 		    reset_global_var_at_key(Key))
     ).
 
@@ -46,10 +48,34 @@ call_cleanup(G, C) :- setup_call_cleanup(true, G, C).
 
 % setup_call_cleanup.
 
-setup_call_cleanup(S, G, C) :- '$get_b_value'(B),
-    S, '$set_cp_by_default'(B), '$get_current_block'(Bb),
-    ( '$call_with_default_policy'(var(C)) -> throw(error(instantiation_error, setup_call_cleanup/3))
-    ; '$call_with_default_policy'(scc_helper(C, G, Bb)) ).
+setup_call_cleanup(S, G, C) :-
+    '$get_b_value'(B),
+    call(S),
+    '$set_cp_by_default'(B),
+    '$get_current_block'(Bb),
+    (  '$call_with_default_policy'(var(C)) ->
+       throw(error(instantiation_error, setup_call_cleanup/3))
+    ;  '$call_with_default_policy'(scc_helper(C, G, Bb))
+    ).
+
+:- non_counted_backtracking scc_helper/3.
+scc_helper(C, G, Bb) :-
+    '$get_cp'(Cp), '$install_scc_cleaner'(C, NBb), call(G),
+    ( '$check_cp'(Cp) ->
+      '$reset_block'(Bb),
+      '$call_with_default_policy'(run_cleaners_without_handling(Cp))
+    ; '$call_with_default_policy'(true)
+    ; '$reset_block'(NBb),
+      '$fail').
+scc_helper(_, _, Bb) :-
+    '$reset_block'(Bb), '$get_ball'(Ball),
+    '$call_with_default_policy'(run_cleaners_with_handling),
+    '$erase_ball',
+    '$call_with_default_policy'(throw(Ball)).
+scc_helper(_, _, _) :-
+    '$get_cp'(Cp),
+    '$call_with_default_policy'(run_cleaners_without_handling(Cp)),
+    '$fail'.
 
 :- non_counted_backtracking run_cleaners_with_handling/0.
 run_cleaners_with_handling :-
@@ -62,27 +88,14 @@ run_cleaners_with_handling :-
 
 :- non_counted_backtracking run_cleaners_without_handling/1.
 run_cleaners_without_handling(Cp) :-
-    '$get_scc_cleaner'(C), '$get_level'(B), C, '$set_cp_by_default'(B),
+    '$get_scc_cleaner'(C),
+    '$get_level'(B),
+    call(C),
+    '$set_cp_by_default'(B),
     '$call_with_default_policy'(run_cleaners_without_handling(Cp)).
 run_cleaners_without_handling(Cp) :-
-    '$set_cp_by_default'(Cp), '$restore_cut_policy'.
-
-:- non_counted_backtracking scc_helper/3.
-scc_helper(C, G, Bb) :-
-    '$get_cp'(Cp), '$install_scc_cleaner'(C, NBb), call(G),
-    ( '$check_cp'(Cp) -> '$reset_block'(Bb),
-			 '$call_with_default_policy'(run_cleaners_without_handling(Cp))
-    ; '$call_with_default_policy'(true)
-    ; '$reset_block'(NBb), '$fail').
-scc_helper(_, _, Bb) :-
-    '$reset_block'(Bb), '$get_ball'(Ball),
-    '$call_with_default_policy'(run_cleaners_with_handling),
-    '$erase_ball',
-    '$call_with_default_policy'(throw(Ball)).
-scc_helper(_, _, _) :-
-    '$get_cp'(Cp),
-    '$call_with_default_policy'(run_cleaners_without_handling(Cp)),
-    '$fail'.
+    '$set_cp_by_default'(Cp),
+    '$restore_cut_policy'.
 
 % call_with_inference_limit
 
@@ -119,9 +132,46 @@ call_with_inference_limit(G, L, R, Bb, B) :-
 call_with_inference_limit(_, _, R, Bb, B) :-
     '$reset_block'(Bb),
     '$remove_inference_counter'(B, _),
-    ( '$get_ball'(Ball), '$get_level'(Cp), '$set_cp_by_default'(Cp)
-    ; '$remove_call_policy_check'(B), '$fail' ),
+    (  '$get_ball'(Ball),
+       '$get_level'(Cp),
+       '$set_cp_by_default'(Cp)
+    ;  '$remove_call_policy_check'(B),
+       '$fail'
+    ),
     '$erase_ball',
     '$call_with_default_policy'(handle_ile(B, Ball, R)).
 
 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))),
+       '$create_partial_string'(Atom, L, L0)
+    ).
+
+partial_string(String) :-
+    '$is_partial_string'(String).
+
+partial_string_tail(String, Tail) :-
+    (  partial_string(String) ->
+       '$partial_string_tail'(String, Tail)
+    ;  throw(error(type_error(partial_string, String), partial_string_tail/2))
+    ).

src/prolog/lib/lists.pl

@@ -1,7 +1,12 @@
-:- module(lists, [member/2, select/3, append/3, memberchk/2,
-		  reverse/2, length/2, maplist/2, maplist/3,
-		  maplist/4, maplist/5, maplist/6, maplist/7,
-		  maplist/8, maplist/9]).
+:- 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]).
+
+
+:- use_module(library(error)).
+
 
 length(Xs, N) :-
     var(N), !,
@@ -30,17 +35,28 @@ length_rundown([_|Xs], N) :-
     N1 is N-1,
     length_rundown(Xs, N1).
 
+
 member(X, [X|_]).
 member(X, [_|Xs]) :- member(X, Xs).
 
+
 select(X, [X|Xs], Xs).
 select(X, [Y|Xs], [Y|Ys]) :- select(X, Xs, Ys).
 
+
+append([], []).
+append([L0|Ls0], Ls) :-
+    append(L0, Rest, Ls),
+    append(Ls0, Rest).
+
+
 append([], R, R).
 append([X|L], R, [X|S]) :- append(L, R, S).
 
+
 memberchk(X, Xs) :- member(X, Xs), !.
 
+
 reverse(Xs, Ys) :-
     (  nonvar(Xs) -> reverse(Xs, Ys, [], Xs)
     ;  reverse(Ys, Xs, [], Ys)
@@ -50,6 +66,7 @@ reverse([], [], YsRev, YsRev).
 reverse([X1|Xs], [Y1|Ys], YsPreludeRev, Xss) :-
     reverse(Xs, Ys, [Y1|YsPreludeRev], Xss).
 
+
 maplist(_, []).
 maplist(Cont1, [E1|E1s]) :-
     call(Cont1, E1),
@@ -89,3 +106,46 @@ 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),
     maplist(Cont, E1s, E2s, E3s, E4s, E5s, E6s, E7s, E8s).
+
+
+sum_list(Ls, S) :-
+        foldl(sum_, Ls, 0, S).
+
+sum_(L, S0, S) :- S is S0 + L.
+
+
+
+same_length([], []).
+same_length([_|As], [_|Bs]) :-
+        same_length(As, Bs).
+
+
+foldl(Goal_3, Ls, A0, A) :-
+        foldl_(Ls, Goal_3, A0, A).
+
+foldl_([], _, A, A).
+foldl_([L|Ls], G_3, A0, A) :-
+        call(G_3, L, A0, A1),
+        foldl_(Ls, G_3, A1, A).
+
+
+foldl(Goal_4, Xs, Ys, A0, A) :-
+        foldl_(Xs, Ys, Goal_4, A0, A).
+
+foldl_([], [], _, A, A).
+foldl_([X|Xs], [Y|Ys], G_4, A0, A) :-
+        call(G_4, X, Y, A0, A1),
+        foldl_(Xs, Ys, G_4, A1, A).
+
+transpose(Ls, Ts) :-
+        lists_transpose(Ls, Ts).
+
+lists_transpose([], []).
+lists_transpose([L|Ls], Ts) :-
+        maplist(same_length(L), Ls),
+        foldl(transpose_, L, Ts, [L|Ls], _).
+
+transpose_(_, Fs, Lists0, Lists) :-
+        maplist(list_first_rest, Lists0, Fs, Lists).
+
+list_first_rest([L|Ls], L, Ls).

src/prolog/lib/pairs.pl

@@ -0,0 +1,21 @@
+:- module(pairs, [pairs_keys_values/3,
+		  pairs_keys/2,
+		  pairs_values/2,
+		  map_list_to_pairs/3]).
+
+
+pairs_keys_values([], [], []).
+pairs_keys_values([A-B|ABs], [A|As], [B|Bs]) :-
+        pairs_keys_values(ABs, As, Bs).
+
+pairs_keys(Ps, Ks) :- pairs_keys_values(Ps, Ks, _).
+
+pairs_values(Ps, Vs) :- pairs_keys_values(Ps, _, Vs).
+
+map_list_to_pairs(Pred, Ls, Ps) :-
+        map_list_to_pairs2(Ls, Pred, Ps).
+
+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).

src/prolog/lib/tabling.pl

@@ -0,0 +1,224 @@
+
+:- module(tabling,
+	  [ start_tabling/2,		% +Wrapper, :Worker.
+
+	    abolish_all_tables/0,
+
+%	    (table)/1,			% +PI ...
+	    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(cont)).
+:- use_module(library(lists)).
+%:- use_module(library(debug)).
+:- use_module(library(iso_ext)).
+
+%% :- meta_predicate
+%% 	start_tabling(+, 0).
+
+%%	user:exception(+Exception, +Var, -Action)
+%
+%	Realises lazy initialization of table variables.
+
+%% user:exception(undefined_global_variable, Var, retry) :-
+%%   (   table_gvar(Var)
+%%   ->  true
+%%   ;   format('Creating global var ~q~n', [Var]),
+%%       nb_setval(Var, [])
+%%   ).
+/*
+table_gvar(trie_table_link) :-
+  table_datastructure_initialize.
+table_gvar(newly_created_table_identifiers) :-
+  table_datastructure_initialize.
+table_gvar(table_global_worklist) :-
+  bb_put(table_global_worklist, []).
+table_gvar(table_leader) :-
+  bb_put(table_leader, []).
+*/
+
+%%	abolish_all_tables
+%
+%	Remove all tables.  Should not be called when tabling is in
+%	progress.
+%
+%	@bug	Check whether tabling is in progress
+
+
+abolish_all_tables :-
+  bb_put(trie_table_link, []),
+  bb_put(newly_created_table_identifiers, []),
+  bb_put(table_global_worklist,[]),
+  bb_put(table_leader, []).
+
+
+% Find table and status for the given call variant.
+%
+table_and_status_for_variant(V,T,S) :-
+  % Order of the two calls really important: first create, then get status
+  table_for_variant(V,T),
+  tbd_table_status(T,S).
+
+start_tabling(Wrapper,Worker) :-
+  put_new_trie_table_link,
+  put_new_global_worklist,
+  put_new_table_identifiers,
+  table_and_status_for_variant(Wrapper,T,S),
+  ( S == complete ->
+    get_answer(T,Wrapper)
+  ;
+    ( exists_scheduling_component ->
+      run_leader(Wrapper,Worker,T),
+      % Now answer the original query!
+      get_answer(T,Wrapper)
+    ;
+      run_follower(S,Wrapper,Worker,T)
+    )
+  ).
+
+run_follower(fresh,Wrapper,Worker,T) :-
+  activate(Wrapper,Worker,T),
+  shift(call_info(Wrapper,T)).
+
+run_follower(active,Wrapper,_Worker,T) :-
+  shift(call_info(Wrapper,T)).
+
+run_leader(Wrapper,Worker,T) :-
+  create_scheduling_component,
+  activate(Wrapper,Worker,T),
+  completion,
+  unset_scheduling_component.
+
+exists_scheduling_component :-
+  bb_get(table_leader, Leader),
+  Leader == [].
+
+create_scheduling_component :-
+  bb_b_put(table_leader, leaderCreated).
+
+unset_scheduling_component :-
+  bb_put(table_leader, []).
+
+set_all_complete :-
+  get_newly_created_table_identifiers(Ts, _),
+  set_all_complete_(Ts).
+
+set_all_complete_([]).
+set_all_complete_([T|Ts]) :-
+  set_complete_status(T),
+  set_all_complete_(Ts).
+
+cleanup_all_complete :-
+  get_newly_created_table_identifiers(Ts,_),
+  cleanup_all_complete_(Ts).
+
+cleanup_all_complete_([]).
+cleanup_all_complete_([T|Ts]) :-
+  cleanup_after_complete(T),
+  cleanup_all_complete_(Ts).
+
+activate(Wrapper,Worker,T) :-
+    set_active_status(T),
+  (
+    delim(Wrapper,Worker,T),
+    fail
+  ;
+    true
+  ).
+
+delim(Wrapper,Worker,Table) :-
+%   debug(tabling, 'ACT: ~p on ~p', [Wrapper, Table]),
+    reset(Worker,SourceCall,Continuation),
+   ( Continuation == none, var(SourceCall) ->
+     (	 add_answer(Table,Wrapper)
+     ->	 true %debug(tabling, 'ADD: ~p', [Wrapper])
+     ;	 %debug(tabling, 'DUP: ~p', [Wrapper]),
+	 fail
+     )
+   ;
+     (   Continuation = cont(Cont) ->
+	     true
+     ;   Continuation = none ->
+	     Cont = true
+     ),
+     SourceCall = call_info(_,SourceTable),
+     TargetCall = call_info(Wrapper,Table),
+     Dependency = dependency(SourceCall,Cont,TargetCall),
+     %debug(tabling, 'DEP: ~p: ~p', [SourceTable,Dependency]),
+     store_dependency(SourceTable,Dependency)
+   ).
+
+completion :-
+  ( worklist_empty ->
+    set_all_complete,
+    cleanup_all_complete,
+    % The place of the call to reset is really important: it must happen after the completion. If you do it before, you will wrongly remove yourself from the list of newly created table identifiers. On starting hProlog there are no newly created table identifiers, and nb_getval gives [] which is the perfect value.
+    reset_newly_created_table_identifiers
+  ;
+    pop_worklist(Table),
+    completion_step(Table),
+    completion
+  ).
+
+completion_step(SourceTableID) :-
+  bb_get(SourceTableID, Table),
+  get_nb_identifiers(Table, NBWorklistID, _),
+  (
+    table_get_work(NBWorklistID,Answer,dependency(Source,Continuation,Target)),
+    Source = call_info(Answer,_),
+    Target = call_info(Wrapper,TargetTable),
+    delim(Wrapper,Continuation,TargetTable),
+    fail
+  ;
+    true
+  ).
+
+table_get_work(NBWorklistID,Answer,Dependency) :-
+  % get_worklist(Table, Worklist),
+  % NOT IN PAPER (could be part of the definition of pop_worklist):
+  bb_get(NBWorklistID, table_nb_worklist(Worklist)),
+  unset_global_worklist_presence_flag(Worklist),
+  set_flag_executing_all_work(Worklist),
+  bb_put(NBWorklistID, table_nb_worklist(Worklist)),
+  table_get_work_(NBWorklistID,Answer,Dependency).
+
+table_get_work_(NBWorklistID,Answer,Dependency) :-
+  worklist_do_all_work(NBWorklistID,Answer,Dependency0), % This will eventually fail
+  copy_term(Dependency0,Dependency).
+
+table_get_work_(NBWorklistID,_Answer,_Dependency) :-
+  bb_get(NBWorklistID, table_nb_worklist(Worklist)),
+  unset_flag_executing_all_work(Worklist),
+  bb_put(NBWorklistID, table_nb_worklist(Worklist)),
+  fail.
+
+worklist_do_all_work(NBWorklistID,Answer,Dependency) :-
+  ( bb_get(NBWorklistID, table_nb_worklist(Worklist)),
+    wkl_worklist_work_done(Worklist) ->
+    fail
+  ;
+    worklist_do_step(NBWorklistID,Answer,Dependency)
+  ;
+    worklist_do_all_work(NBWorklistID,Answer,Dependency)
+  ).
+
+worklist_do_step(NBWorklistID,Answer,Dependency) :-
+  bb_get(NBWorklistID, table_nb_worklist(Worklist)),
+  wkl_p_get_rightmost_inner_answer_cluster_pointer(Worklist,ACP),
+  wkl_p_swap_answer_continuation(Worklist,ACP,SCP),
+  dll_get_data(ACP,wkl_answer_cluster(AListFlag)),
+  dll_get_data(SCP,wkl_suspension_cluster(SListFlag)),
+  get_atts(AListFlag, batched_worklist, wkl_answer_cluster(AList)),
+  get_atts(SListFlag, batched_worklist, wkl_suspension_cluster(SList)),
+  bb_put(NBWorklistID, table_nb_worklist(Worklist)),
+  member(Answer,AList),
+  member(Dependency,SList).
+
+:- initialization(bb_put(table_leader, [])).

src/prolog/lib/tabling/batched_worklist.pl

@@ -0,0 +1,389 @@
+/*  Part of SWI-Prolog
+
+    Author:        Benoit Desouter <Benoit.Desouter@UGent.be>
+		   Jan Wielemaker (SWI-Prolog port)
+    Copyright (c)  2016, Benoit Desouter
+    All rights reserved.
+
+    Ported to Scryer Prolog by Mark Thom (2019/2020).
+
+    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(batched_worklist,
+	  [ wkl_add_answer/2,				% +WorkList, +Answer
+	    wkl_add_suspension/2,			% +Worklist, +Suspension
+	    wkl_new_worklist/2,				% +TableID, -WorkList
+	    unset_flag_executing_all_work/1,		% +WorkList
+	    unset_global_worklist_presence_flag/1,	% +WorkList
+	    set_flag_executing_all_work/1,		% +WorkList
+	    wkl_p_get_rightmost_inner_answer_cluster_pointer/2, % +WorkList, -Cluster
+	    wkl_p_swap_answer_continuation/3,		% +WorkList, +Cluster1, +Cluster2
+	    wkl_worklist_work_done/1			% +WorkList
+	  ]).
+
+:- use_module(global_worklist).
+:- use_module(double_linked_list).
+
+:- use_module(library(atts)).
+:- use_module(library(lists)).
+
+:- attribute executing_all_work/1, worklist_presence/1, wkl_answer_cluster/1, wkl_suspension_cluster/1, wkl_answer_cluster_pointer_flag/1.
+
+/** <module> Tabling Worklist management
+
+A batched worklist: a worklist that  clusters suspensions and answers as
+much as possible. The idea is  to   minimize  the  number of swaps. This
+should be more  efficient  than   the  worklist  implementation  without
+clustering.
+
+Argument positions for nb_setarg:
+
+ 1. double linked list
+ 2. pointer to the list entry of the rightmost inner answer cluster
+ 3. flag indicating the execution of wkl_unfolded_do_all_work
+ 4. flag indicating whether the table identifier associated with this
+    worklist is already in the global worklist. This is because more
+    than one answer can be added due to the execution of other
+    worklists. 5: table identifier for the table this worklist belongs
+    to
+
+Contents of a batched worklist:
+
+ - wkl_answer_cluster([Answer|RestAnswers]).
+ - wkl_suspension([Suspension|RestSuspension]).
+
+The difficulty is that you should not add  new entries to a cluster once
+you started its execution. Probably the  simplest   way  to  do so is by
+swapping the answer cluster AC and suspension cluster SC before you take
+the cartesian product of all answers in AC with all suspensions in SC.
+
+Illustration why you may need a complex procedure for finding the future
+rightmost inner answer cluster.
+
+Assume all clusters have 2 entries.
+
+ 1. AA1 CC1
+ 2. AA2 CC1 AA1 CC2 (swapped AA1 and CC1)
+ 3. AA2 CC1 CC2 AA1 (swapped AA1 and CC2)
+ 4. AA3 CC1 AA2 CC2 AA1 CC3 (swapped AA2 and CC1)
+
+Now AA1 is the RIAC, but AA2 is the future RIAC.
+
+Can you find the future RIAC smarter than by walking back? If you don't,
+then it doesn't make sense to use a future  RIAC at all. You could use a
+stack, which should not grow too  large   because  you  use batches. But
+walking back also should not take too long, since you use batches.
+
+So let's not use a future RIAC in   the  first place, and just walk back
+when we need a new RIAC. This is   easy  to implement, hence we can test
+more quickly.
+
+Abbreviations:
+
+ - RIAC = rightmost inner answer cluster
+ - FUTRIAC = future rightmost inner answer cluster
+*/
+
+%%	wkl_new_worklist(+TableID, -WorkList) is det.
+%
+%	Create a new worklist for  TableID  and   add  it  to the global
+%	worklist list (global variable `table_global_worklist`.
+
+wkl_new_worklist(TableIdentifier, wkl_worklist(List,AnswerClusterPointerFlag,ExecutingAllWork,WorklistPresence,TableIdentifier)) :-
+  dll_new_double_linked_list(List),
+  put_atts(AnswerClusterPointerFlag, wkl_answer_cluster_pointer_flag(List)),
+  % We set the RIAC to the dummy element at the start of the double linked list, which is List.
+  % Don't set all the rest for now.
+  put_atts(ExecutingAllWork, executing_all_work(false)),
+  put_atts(WorklistPresence, worklist_presence(true)),
+  add_to_global_worklist(TableIdentifier).
+
+%%	wkl_worklist_work_done(+WorkList) is semidet.
+%
+%	The work is done if the RIAC   pointer points to the unused cell
+%	at the beginning. The work is  also   done  if  the RIAC pointer
+%	points to the  sole  answer  cluster   in  a  list  dll_start  -
+%	wkl_answer_cluster,  because  in  that   case    there   are  no
+%	suspensions to swap with. This is a  special case, which we only
+%	discovered by testing. You can detect it by checking whether the
+%	NEXT-pointer of the RIAC is the dummy pointer.
+
+wkl_worklist_work_done(Worklist) :-
+  wkl_p_get_rightmost_inner_answer_cluster_pointer(Worklist,RiacPointer),
+  ( wkl_is_dummy_pointer(Worklist,RiacPointer) ->
+    true
+  ;
+    dll_get_pointer_to_next(RiacPointer,NextPointer),
+    wkl_is_dummy_pointer(Worklist,NextPointer)
+  ).
+
+set_flag_executing_all_work(wkl_worklist(_,_,ExecutingAllWork,_,_)) :-
+  put_atts(ExecutingAllWork, executing_all_work(true)).
+
+unset_flag_executing_all_work(wkl_worklist(_,_,ExecutingAllWork,_,_)) :-
+  put_atts(ExecutingAllWork, executing_all_work(false)).
+
+% Swap answer cluster and the adjacent continuation cluster.
+% Mode: + + -
+wkl_p_swap_answer_continuation(Worklist,InnerAnswerClusterPointer,SuspensionClusterPointer) :-
+  % You can have a worklist containing only an answer cluster, but no continuations.
+  % In that case SuspensionClusterPointer will be dll_start. We must take our precautions elsewhere.
+  % Do not forget that the list of answers and the list of suspensions is wrapped in a predicate!
+  dll_get_pointer_to_next(InnerAnswerClusterPointer,SuspensionClusterPointer),
+  % For reasons of speed we don't use dll_swap: we only swap adjacent elements and we can be sure that they are in the order A,B.
+  % Therefore we can use dll_p_swap_adjacent_elements_
+  dll_p_swap_adjacent_elements_(InnerAnswerClusterPointer,SuspensionClusterPointer),
+  % Update the necessary pointers
+  wkl_p_update_righmost_inner_answer_cluster_pointer(Worklist,InnerAnswerClusterPointer).
+
+% Update the pointer if the answer cluster it points to is no longer the rightmost inner answer cluster.
+wkl_p_update_righmost_inner_answer_cluster_pointer(Worklist,InnerAnswerClusterPointer) :-
+  ( wkl_p_answer_cluster_currently_moved_completely(Worklist,InnerAnswerClusterPointer) ->
+    wkl_p_find_new_rightmost_inner_answer_cluster_pointer(Worklist,InnerAnswerClusterPointer,NewRiacPointer),
+    wkl_p_set_rightmost_inner_answer_cluster_pointer(Worklist,NewRiacPointer)
+  ;
+    true
+  ).
+
+% Rationale for this implementation: see the top of the file.
+% Unify NewRiacPointer to the first pointer satisfying the following conditions:
+% - left of StartPointer (when viewing the list as DUMMY-ELEM POINTER POINTER POINTER START-POINTER)
+% - either an anwer pointer or the dummy element
+% When StartPointer is the dummy element, NewRiacPointer is also the dummy element. We never look "in front of" the dummy element.
+wkl_p_find_new_rightmost_inner_answer_cluster_pointer(Worklist,StartPointer,NewRiacPointer) :-
+  ( wkl_is_dummy_pointer(Worklist,StartPointer) ->
+    NewRiacPointer = StartPointer
+  ;
+    dll_get_pointer_to_previous(StartPointer,FirstCandidatePointer),
+    wkl_p_find_new_riac_helper(Worklist,FirstCandidatePointer,NewRiacPointer)
+  ).
+
+wkl_p_find_new_riac_helper(Worklist,CandidatePointer,NewRiacPointer) :-
+  ( is_answer_cluster_or_dummy_pointer(Worklist,CandidatePointer) ->
+    NewRiacPointer = CandidatePointer
+  ;
+    dll_get_pointer_to_previous(CandidatePointer,NewCandidate),
+    wkl_p_find_new_riac_helper(Worklist,NewCandidate,NewRiacPointer)
+  ).
+
+is_answer_cluster_or_dummy_pointer(Worklist,Pointer) :-
+  ( wkl_is_dummy_pointer(Worklist,Pointer) ->
+    true
+  ;
+    wkl_p_dereference_pointer(Worklist,Pointer,A),
+    wkl_p_is_answer_cluster(A)
+  ).
+
+% Failure-driven loop
+wkl_clusters_cartesian_product(AnswerCluster,SuspensionCluster) :-
+  ( member(Answer,AnswerCluster),
+    member(Suspension,SuspensionCluster),
+    % The meat
+    run_worklist_helper(Suspension,Answer),
+    % Trigger loop
+    fail
+  ;
+    % Loop base case
+    true
+  ).
+
+run_worklist_helper(_Suspension, _Answer) :-	% FIXME: just silense
+  throw('not implemented').
+
+wkl_both_flags_unset(wkl_worklist(_Dll,_Riac,ExecutingAllWork,WorklistPresence,_TableIdentifier)) :-
+  put_atts(ExecutingAllWork, executing_all_work(false)),
+  put_atts(WorklistPresence, worklist_presence(false)).
+
+set_global_worklist_presence_flag(wkl_worklist(_,_,_,WorklistPresence,_)) :-
+  put_atts(WorklistPresence, worklist_presence(true)).
+
+unset_global_worklist_presence_flag(wkl_worklist(_,_,_,WorklistPresence,_)) :-
+  put_atts(WorklistPresence, worklist_presence(false)).
+
+potentially_add_to_global_worklist(Worklist) :-
+  ( wkl_both_flags_unset(Worklist) ->
+    % Set the flag for presence in the metaworklist
+    set_global_worklist_presence_flag(Worklist),
+    % Should add to the metaworklist
+    arg(5,Worklist,TableIdentifier),
+    add_to_global_worklist(TableIdentifier)
+  ;
+  % Nothing to do.
+    true
+  ).
+
+wkl_add_answer(Worklist,Answer) :-
+  % Add to global worklist if not executing during wkl_unfolded_do_all_work and not there yet as well.
+    potentially_add_to_global_worklist(Worklist),
+  ( wkl_p_leftmost_cluster_is_answer_cluster(Worklist) ->
+    wkl_add_to_existing_answer_cluster(Worklist,Answer)
+    % If you add to an existing cluster, then obviously you should not change the RIAC.
+  ;
+    wkl_add_to_new_answer_cluster(Worklist,Answer,AnswerClusterPointer),
+    % If the RIAC is the dummy pointer, we need to change that.
+    wkl_p_update_rightmost_inner_answer_cluster_pointer(Worklist,AnswerClusterPointer)
+  ).
+
+wkl_p_update_rightmost_inner_answer_cluster_pointer(Worklist,NewAnswerClusterPointer) :-
+  wkl_p_get_rightmost_inner_answer_cluster_pointer(Worklist,CurrentRiac),
+  ( wkl_is_dummy_pointer(Worklist,CurrentRiac) -> %% <- debugging this.
+    wkl_p_set_rightmost_inner_answer_cluster_pointer(Worklist,NewAnswerClusterPointer)
+  ;
+    % Nothing to do.
+    true
+  ).
+
+wkl_add_suspension(Worklist,Suspension) :-
+  % Add to global worklist if not executing during wkl_unfolded_do_all_work and not there yet as well.
+  potentially_add_to_global_worklist(Worklist),
+  ( wkl_p_rightmost_cluster_is_suspension_cluster(Worklist) ->
+    wkl_add_to_existing_suspension_cluster(Worklist,Suspension)
+  ;
+    wkl_add_to_new_suspension_cluster(Worklist,Suspension,SuspensionClusterPointer),
+    % If added to a new suspension cluster, we may need to change the righmost inner answer pointer
+    wkl_p_potential_rias_update_add_contin(Worklist,SuspensionClusterPointer)
+  ).
+
+% This predicate should not fail.
+wkl_p_potential_rias_update_add_contin(Worklist,SuspensionClusterPointer) :-
+  % Look back one entry of the freshly inserted SuspensionClusterPointer
+  dll_get_pointer_to_previous(SuspensionClusterPointer,PotentialNewRiacPointer),
+  ( wkl_p_is_answer_cluster_pointer(Worklist,PotentialNewRiacPointer) ->
+    % We must indeed update the rightmost inner answer cluster pointer.
+    wkl_p_set_rightmost_inner_answer_cluster_pointer(Worklist,PotentialNewRiacPointer)
+  ;
+    % Nothing to do, but we should not fail.
+    true
+  ).
+
+wkl_add_to_existing_answer_cluster(Worklist, Answer) :-
+  arg(1,Worklist,Dll),
+  dll_get_pointer_to_next(Dll,AnswerClusterPointer),
+  wkl_p_dereference_pointer(Worklist,AnswerClusterPointer,AnswerCluster),
+  AnswerCluster = wkl_answer_cluster(AnswersFlag),
+  get_atts(AnswersFlag, wkl_answer_cluster(AnswersAlreadyInCluster)),
+  put_atts(AnswersFlag, wkl_answer_cluster([Answer|AnswersAlreadyInCluster])).
+
+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])).
+
+wkl_add_to_existing_suspension_cluster(Worklist, Suspension) :-
+  arg(1,Worklist,Dll),
+  dll_get_pointer_to_previous(Dll,SuspensionClusterPointer),
+  wkl_p_dereference_pointer(Worklist,SuspensionClusterPointer,SuspensionCluster),
+  SuspensionCluster = wkl_suspension_cluster(SuspensionsFlag),
+  get_atts(SuspensionsFlag, wkl_suspension_cluster(SuspensionsAlreadyInCluster)),
+  put_atts(SuspensionsFlag, wkl_suspension_cluster([Suspension|SuspensionsAlreadyInCluster])).
+  %% nb_linkarg(1,SuspensionCluster,[Suspension|SuspensionsAlreadyInCluster]).
+
+wkl_add_to_new_suspension_cluster(
+    wkl_worklist(Dll,_Ria,_FlagExecutingWork,_AlreadyInMetaworklist,_TableIdentifier),
+    Suspension,
+    SuspensionClusterPointer
+) :-
+  put_atts(SuspensionFlag, wkl_suspension_cluster([Suspension])),
+  dll_append_right(Dll,wkl_suspension_cluster(SuspensionFlag),SuspensionClusterPointer).
+
+wkl_p_is_answer_cluster(CandidateAnswerCluster) :-
+  nonvar(CandidateAnswerCluster),
+  CandidateAnswerCluster = wkl_answer_cluster(_).
+
+wkl_p_is_suspension_cluster(CandidateSuspensionCluster) :-
+  nonvar(CandidateSuspensionCluster),
+  CandidateSuspensionCluster = wkl_suspension_cluster(_).
+
+wkl_p_leftmost_cluster_is_answer_cluster(Worklist) :-
+  arg(1,Worklist,Dll),
+  dll_get_pointer_to_next(Dll,CandidateAnswerClusterPointer),
+  wkl_p_is_answer_cluster_pointer(Worklist,CandidateAnswerClusterPointer).
+
+wkl_p_rightmost_cluster_is_suspension_cluster(Worklist) :-
+  arg(1,Worklist,Dll),
+  dll_get_pointer_to_previous(Dll,CandidateSuspensionClusterPointer),
+  wkl_p_is_suspension_cluster_pointer(Worklist,CandidateSuspensionClusterPointer).
+
+
+wkl_p_get_rightmost_inner_answer_cluster_pointer(wkl_worklist(_Dll,InnerAnswerClusterPointerFlag,_FlagExecutingWork,_AlreadyInMetaworklist,_TableIdentifier), InnerAnswerClusterPointer) :-
+  get_atts(InnerAnswerClusterPointerFlag, wkl_answer_cluster_pointer_flag(InnerAnswerClusterPointer)).
+
+% Succeed if there are currently no more continuation clusters on the right of the given position:
+% Why 'currently' in the name? Another continuation can be added.
+wkl_p_answer_cluster_currently_moved_completely(Worklist,AnswerClusterPointer) :-
+  ( wkl_p_at_right(Worklist,AnswerClusterPointer) ->
+    true
+  ;
+    wkl_p_answer_cluster_on_right(Worklist,AnswerClusterPointer)
+  ).
+
+% Succeeds if the given pointer points to the last element in the list. That is, if its next pointer is the dummy element in the double linked list.
+wkl_p_at_right(Worklist,Pointer) :-
+  dll_get_pointer_to_next(Pointer,NextPointer),
+  wkl_is_dummy_pointer(Worklist,NextPointer).
+
+wkl_p_answer_cluster_on_right(Worklist,Pointer) :-
+  dll_get_pointer_to_next(Pointer,NextPointer),
+  wkl_p_is_answer_cluster_pointer(Worklist,NextPointer).
+
+wkl_is_dummy_pointer(Worklist,Pointer) :-
+  wkl_p_get_double_linked_list(Worklist,Dll),
+  dll_is_dummy_pointer(Dll,Pointer).
+
+wkl_p_is_answer_cluster_pointer(Worklist,PointerCandidateAnswerCluster) :-
+  ( wkl_is_dummy_pointer(Worklist,PointerCandidateAnswerCluster) ->
+    % Certainly not an answer cluster, should not dereference this
+    fail
+  ;
+    wkl_p_dereference_pointer(Worklist,PointerCandidateAnswerCluster,CandidateAnswerCluster),
+    wkl_p_is_answer_cluster(CandidateAnswerCluster)
+  ).
+
+wkl_p_is_suspension_cluster_pointer(Worklist,PointerCandidateSuspensionCluster) :-
+  ( wkl_is_dummy_pointer(Worklist,PointerCandidateSuspensionCluster) ->
+    % Certainly not an answer cluster, should not dereference this
+    fail
+  ;
+    wkl_p_dereference_pointer(Worklist,PointerCandidateSuspensionCluster,CandidateSuspensionCluster),
+    wkl_p_is_suspension_cluster(CandidateSuspensionCluster)
+  ).
+
+wkl_p_get_double_linked_list(Worklist,Dll) :-
+  arg(1,Worklist,Dll).
+
+% One should not attempt to dereference the dummy pointer in the double linked list.
+wkl_p_dereference_pointer(_Worklist,Pointer,Data) :-
+  dll_get_data(Pointer,Data).
+
+% SETTING POINTERS
+%%%%%%%%%%%%%%%%%%
+
+wkl_p_set_rightmost_inner_answer_cluster_pointer(Worklist,AnswerClusterPointer) :-
+  arg(2, Worklist, AnswerClusterPointerFlag),
+  put_atts(AnswerClusterPointerFlag, wkl_answer_cluster_pointer_flag(AnswerClusterPointer)).

src/prolog/lib/tabling/double_linked_list.pl

@@ -0,0 +1,210 @@
+/*  Part of SWI-Prolog
+
+    Author:        Benoit Desouter <Benoit.Desouter@UGent.be>
+		   Jan Wielemaker (SWI-Prolog port)
+    Copyright (c)  2016, Benoit Desouter
+    All rights reserved.
+
+    Ported to Scryer Prolog by Mark Thom (2019/2020).
+
+    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(double_linked_list,
+	  [ dll_new_double_linked_list/1,	% -List
+	    dll_append_right/2,			% !List, +Element
+	    dll_append_left/2,			% !List, +Element
+	    dll_append_right/3,			% !List, +Element, -Pointer
+	    dll_append_left/3,			% !List, +Element, -Pointer
+	    dll_get_data/2,			% +List, -Head
+	    dll_get_pointer_to_next/2,		% +List, -Pointer
+	    dll_get_pointer_to_previous/2,	% +List, -Pointer
+	    dll_is_dummy_pointer/2,		% +List, +Pointer
+	    dll_p_swap_adjacent_elements_/2,	% +Pointer1, +Pointer2
+	    dll_get_contents/2,
+	    dll_get_reverse_contents/2
+	  ]).
+
+:- use_module(library(atts)).
+
+:- attribute dll_element/1, dll_next/1, dll_prev/1.
+
+% A circular double linked list
+% =============================
+
+% Always have a unused-cell at the beginning.
+
+% I do not always inline unifications because the head is then more readable for users who don't need to know the details.
+
+% Due to lack of modules in hProlog, the following predicate names should not be used elsewhere:
+% - the heads of all following rules (starting with dll_, I reserve "the namespace"!)
+
+% dll_cell(Element,Next,Previous)
+
+% The following is perhaps odd:
+%
+%   Next link = more to the front (the left)
+%   Previous link = more to the back (the right)
+%
+%   List structure
+%   --------------
+%   front-of-the-list | ... | back-of-the-list
+
+dll_new_double_linked_list(List) :-
+    % Nonused cell dll_start at the beginning, points to itself (this is easy when adding elements).
+    List = dll_cell(Start),
+    put_atts(Start, [dll_next(List), dll_prev(List), dll_element(dll_start)]).
+
+dll_append_right(List, Element) :-
+  dll_append_right(List, Element, _).
+
+dll_append_left(List, Element) :-
+  dll_append_left(List, Element, _).
+
+% Append at the back of the list
+% Mode: + + -
+dll_append_right(List, Element, Pointer) :-
+  % Get pointer to cell currently at the back. Done by taking the previous element from the unused element representing the list.
+  dll_get_pointer_to_previous(List, OldBack),
+  % Make the new cell point to OldBack as predecessor
+  % Make the new cell point to the unused cell as successor.
+  Pointer = dll_cell(NewCell),
+  put_atts(NewCell, [dll_element(Element), dll_next(List), dll_prev(OldBack)]),
+  % Make OldBack point to the new cell as successor
+  dll_p_set_next_pointer(OldBack, Pointer),
+  % Make the unused cell point to the new cell as predecessor
+  dll_p_set_previous_pointer(List, Pointer).
+
+% Add to the front of the list
+% Mode: + + -
+dll_append_left(List, Element, Pointer) :-
+    % Get pointer to cell currently at the front. Done by taking the next element from the unused element representing the list.
+    dll_get_pointer_to_next(List, OldFront),
+    % Make the new cell point to OldFront as successor
+    % Make the new cell point to the unused cell as predecessor
+    Pointer = dll_cell(NewCell),
+    put_atts(NewCell, [dll_element(Element), dll_prev(List), dll_next(OldFront)]),
+    % Make OldFront point to the new cell as predecessor
+    dll_p_set_previous_pointer(OldFront, Pointer),
+    % Make the unused cell point to the new cell as successor
+    dll_p_set_next_pointer(List, Pointer).
+
+% get_next_cell?
+dll_get_pointer_to_next(dll_cell(Cell), PointerNext) :-
+    get_atts(Cell, dll_next(PointerNext)).
+
+% get_previous_cell?
+dll_get_pointer_to_previous(dll_cell(Cell), PointerPrevious) :-
+    get_atts(Cell, dll_prev(PointerPrevious)).
+
+% Will happily give you the "data" from the unused cell at the beginning. (We use this odd behaviour below, f.e. in dll_p_foreach_element_/2.)
+dll_get_data(dll_cell(Cell), Element) :-
+    get_atts(Cell, dll_element(Element)).
+
+dll_is_dummy_pointer(List, Pointer) :-
+    dll_get_contents(List, ListContents),
+    dll_get_contents(Pointer, PointerContents),
+    \+ PointerContents \= ListContents.
+
+% Special case of swapping - used in dll_swap/2.
+% This is also the case used for swapping a freshly created list with itself.
+%
+% Sketch: APrevious <-> PointerA <-> PointerB <-> BNext etc.
+dll_p_swap_adjacent_elements(PointerA, PointerB) :-
+    % Order B A?
+    ( dll_get_pointer_to_next(PointerB, PointerA) ->
+      dll_p_swap_adjacent_elements_(PointerB, PointerA)
+    ;
+      % Order A B!
+      dll_p_swap_adjacent_elements_(PointerA, PointerB)
+    ).
+
+% Assumes the order A B.
+dll_p_swap_adjacent_elements_(PointerA, PointerB) :-
+    % Get A's previous and B's next
+    dll_get_pointer_to_previous(PointerA, PointerAPrevious),
+    dll_get_pointer_to_next(PointerB, PointerBNext),
+    % Set A's previous to B
+    dll_p_set_previous_pointer(PointerA, PointerB),
+    % Set B's next to A
+    dll_p_set_next_pointer(PointerB, PointerA),
+    % Set A's next to BNext
+    dll_p_set_next_pointer(PointerA, PointerBNext),
+    % Set B's previous to APrevious
+    dll_p_set_previous_pointer(PointerB, PointerAPrevious),
+    % Set APrevious' next to B !!
+    dll_p_set_next_pointer(PointerAPrevious, PointerB),
+    % Set BNext's previous to A !!
+    dll_p_set_previous_pointer(PointerBNext, PointerA).
+
+% Private
+% Careful: make sure this is called on the actual cell, and not some copy.
+% Mode: + +
+dll_p_set_previous_pointer(dll_cell(Cell), PointerToNewPrevious) :-
+    put_atts(Cell, dll_prev(PointerToNewPrevious)).
+
+% Private
+% Careful: make sure this is called on the actual cell, and not some copy.
+% Mode: + +
+dll_p_set_next_pointer(dll_cell(Cell), PointerToNewNext) :-
+    put_atts(Cell, dll_next(PointerToNewNext)).
+
+dll_extract_element(ElementFlag, Element) :-
+    (  ElementFlag = wkl_suspension_cluster(SuspensionClusterFlag) ->
+       get_atts(SuspensionClusterFlag, batched_worklist, wkl_suspension_cluster(SuspensionCluster)),
+       Element = wkl_suspension_cluster(SuspensionCluster)
+    ;  ElementFlag = wkl_answer_cluster(AnswerClusterFlag) ->
+       get_atts(AnswerClusterFlag, batched_worklist, wkl_answer_cluster(AnswerCluster)),
+       Element = wkl_answer_cluster(AnswerCluster)
+    ).
+
+dll_get_contents(List, Contents) :-
+    dll_get_pointer_to_next(List, Next),
+    dll_get_contents_(Next, Contents).
+
+dll_get_contents_(List, Contents) :-
+    dll_get_data(List, ElementFlag),
+    (  ElementFlag == dll_start ->
+       Contents = []
+    ;  dll_extract_element(ElementFlag, Element),
+       Contents = [Element | Rest],
+       dll_get_pointer_to_next(List, Next),
+       dll_get_contents_(Next, Rest)
+    ).
+
+dll_get_reverse_contents(List, Contents) :-
+    dll_get_pointer_to_previous(List, Prev),
+    dll_get_reverse_contents_(Prev, Contents).
+
+dll_get_reverse_contents_(List, Contents) :-
+    dll_get_data(List, ElementFlag),
+    (  ElementFlag == dll_start ->
+       Contents = []
+    ;  dll_extract_element(ElementFlag, Element),
+       Contents = [Element | Rest],
+       dll_get_pointer_to_previous(List, Prev),
+       dll_get_reverse_contents_(Prev, Rest)
+    ).

src/prolog/lib/tabling/global_worklist.pl

@@ -0,0 +1,40 @@
+/*    Ported to Scryer Prolog by Mark Thom (2019/2020).
+ */
+
+:- module(global_worklist,
+	  [ put_new_global_worklist/0,
+	    add_to_global_worklist/1,
+	    worklist_empty/0,
+	    pop_worklist/1
+	  ]).
+
+:- use_module(library(atts)).
+:- use_module(library(iso_ext)).
+
+:- attribute table_global_worklist/1.
+
+put_new_global_worklist :-
+  (  bb_get(table_global_worklist_initialized, _) ->
+     true
+  ;  put_atts(Worklist, table_global_worklist([])),
+     bb_put(table_global_worklist, Worklist),
+     bb_b_put(table_global_worklist_initialized, [])
+  ).
+
+add_to_global_worklist(TableIdentifier) :-
+  bb_get(table_global_worklist, TableGlobalWorklistFlag),
+  get_atts(TableGlobalWorklistFlag, table_global_worklist(L1)),
+  put_atts(TableGlobalWorklistFlag, table_global_worklist([TableIdentifier|L1])),
+  bb_put(table_global_worklist, TableGlobalWorklistFlag).
+
+worklist_empty :-
+  bb_get(table_global_worklist,TableGlobalWorklistFlag),
+  get_atts(TableGlobalWorklistFlag, table_global_worklist(L)),
+  L == [].
+
+pop_worklist(TableIdentifier) :-
+  bb_get(table_global_worklist,TableGlobalWorklistFlag),
+  get_atts(TableGlobalWorklistFlag, table_global_worklist(L1)),
+  L1 = [TableIdentifier|L2],
+  put_atts(TableGlobalWorklistFlag, table_global_worklist(L2)),
+  bb_put(table_global_worklist, TableGlobalWorklistFlag).

src/prolog/lib/tabling/table_data_structure.pl

@@ -0,0 +1,253 @@
+:- module(table_datastructure,
+	  [ get_answer/2,			% +TableID, -Answer
+	    add_answer/2,			% +TableID, +Answer
+	    get_call_variant/2,			% +TableID, -CallVariant
+	    set_complete_status/1,		% +TableID
+	    set_active_status/1,		% +TableID
+	    tbd_table_status/2,			% +TableID, -Status
+	    table_for_variant/2,		% +Variant, -TableID
+	    store_dependency/2,			% +TableID, +Suspension
+	    cleanup_after_complete/1,		% +TableID
+	    get_newly_created_table_identifiers/2, % NewlyCreatedTableIDs, NumIDs
+	    reset_newly_created_table_identifiers/0,
+	    answers_for_variant/2,	        % +Variant, -Answers
+	    put_new_table_identifiers/0,
+	    get_nb_identifiers/3                % +Table, -NbWorklistID, -NbAnswerTreeID
+	  ]).
+
+:- use_module(table_link_manager).
+:- use_module(trie).
+
+/*  Part of SWI-Prolog
+
+    Author:        Benoit Desouter <Benoit.Desouter@UGent.be>
+		   Jan Wielemaker (SWI-Prolog port)
+    Copyright (c)  2016, Benoit Desouter
+    All rights reserved.
+
+    Ported to Scryer Prolog by Mark Thom (2019/2020).
+
+    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.
+*/
+
+:- use_module(batched_worklist).
+
+:- use_module(library(atts)).
+:- use_module(library(gensym)).
+:- use_module(library(iso_ext)).
+
+:- attribute table_status/1, newly_created_table_identifiers/1.
+
+% This file defines the table datastructure.
+%
+% The table datastructure contains the following sub-structures:
+% - the answer trie
+% - the worklist
+%
+% Structure for tables:
+% table(CallVariant,Status,AnswerTrie,Worklist) or complete_table(CallVariant,AnswerTrie).
+% where AnswerTrie contains a trie of unique answers
+%
+% Remember that a table may also be nonexistent!
+% nb_getval(nonexistent,X) then gives [].
+
+put_new_table_identifiers :-
+  (  bb_get(newly_created_table_identifiers_initialized, _) ->
+     true
+  ;  put_atts(NewlyCreatedFlag, newly_created_table_identifiers([]-0)),
+     bb_b_put(newly_created_table_identifiers, NewlyCreatedFlag),
+     bb_b_put(newly_created_table_identifiers_initialized, [])
+  ).
+
+% Returns a list of newly created table identifiers since the last call to reset_newly_created_table_identifiers/0, as well as the length of the list.
+get_newly_created_table_identifiers(NewlyCreatedTableIdentifiers,NumIdentifiers) :-
+  bb_get(newly_created_table_identifiers, NewlyCreatedFlag),
+  get_atts(NewlyCreatedFlag, newly_created_table_identifiers(NewlyCreatedTableIdentifiers-NumIdentifiers)).
+
+reset_newly_created_table_identifiers :-
+  bb_get(newly_created_table_identifiers, NewlyCreatedFlag),
+  put_atts(NewlyCreatedFlag, newly_created_table_identifiers([]-0)).
+
+add_to_newly_created_table_identifiers(TableIdentifier) :-
+  bb_get(newly_created_table_identifiers, NewlyCreatedFlag),
+  get_atts(NewlyCreatedFlag, newly_created_table_identifiers(L1-Num1)),
+  Num2 is Num1 + 1,
+  put_atts(NewlyCreatedFlag, newly_created_table_identifiers([TableIdentifier|L1]-Num2)).
+
+% PRIVATE
+% Mode: + -
+%
+% Created in the fresh status.
+p_create_table(CallVariant,TableIdentifier) :-
+  % We use a copy_term here so that we can be sure not to corrupt our table if CallVariant is "changed" afterwards.
+  copy_term(CallVariant,CallVariant2),
+  % Generate a table identifier, create the table and do bookkeeping.
+  gensym(table,TableIdentifier),
+  % Create a trie and a worklist.
+  trie_new(EmptyTrie),
+  wkl_new_worklist(TableIdentifier,NewWorklist),
+  put_atts(StatusFlag, table_status(fresh)),
+  %% this is important! we don't want to copy the incomplete table every time we refer to it,
+  %% which would occur if we used bb_put here.
+  %% note that the complete_table variant is written to the blackboard using bb_get.
+  atom_concat(TableIdentifier, nb_worklist, NbWorklistID),
+  atom_concat(TableIdentifier, nb_answer_trie, NbAnswerTrieID),
+  bb_put(TableIdentifier, table(CallVariant2,StatusFlag,NbWorklistID,NbAnswerTrieID)),
+  bb_put(NbWorklistID, table_nb_worklist(NewWorklist)),
+  bb_put(NbAnswerTrieID, table_nb_answer_trie(EmptyTrie)),
+  p_link_variant_identifier(CallVariant2,TableIdentifier),
+  add_to_newly_created_table_identifiers(TableIdentifier).
+
+% Get the Status for table TableIdentifier
+% Throws exception if this table does not exist.
+tbd_table_status(TableIdentifier,Status) :-
+  p_get_table_for_identifier(TableIdentifier,Table),
+  tbd_table_status_(Table,Status).
+
+% Is also used in other predicates than tbd_table_status.
+tbd_table_status_(table(_CallVariant,StatusFlag,_NbWorklistID, _NbAnswerTrieID),Status) :-
+  get_atts(StatusFlag, table_status(Status)).
+tbd_table_status_(complete_table(_,_,_),complete).
+
+% PRIVATE
+% Table must already exist.
+p_get_table_for_identifier(TableIdentifier,Table) :-
+  bb_get(TableIdentifier,Table).
+
+% Get the table identifier (!!) for call variant V, creating a new one if necessary.
+%
+% More costly than directly passing the table identifier for already existing tables.
+%
+% Since this creates a new table, this predicate is NOT meant for users who should get access to existing tables - f.e. benchmark shortest_path.P
+%
+table_for_variant(V,TableIdentifier) :-
+  ( p_existing_table(V,TableIdentifier) ->
+    true
+  ;
+    p_create_table(V,TableIdentifier)
+  ).
+
+% Get call variant for this table
+get_call_variant(TableIdentifier,CallVariant) :-
+  p_get_table_for_identifier(TableIdentifier,Table),
+  get_call_variant_(Table,CallVariant).
+
+get_call_variant_(table(CallVariant,_Status,_NbWorklistID,_NbAnswerTrieID),CallVariant).
+get_call_variant_(complete_table(CallVariant,_NbWorklistID,_NbAnswerTrieID),CallVariant).
+
+add_answer(TableIdentifier,A) :-
+  p_get_table_for_identifier(TableIdentifier,Table),
+% arg(1,Table,CallVariant),
+  arg(3,Table,NbWorklistID),
+  arg(4,Table,NbAnswerTrieID),
+  bb_get(NbWorklistID,table_nb_worklist(Worklist)),
+  bb_get(NbAnswerTrieID,table_nb_answer_trie(AnswerTrie)),
+  copy_term(A,A2),
+  % This predicate succeeds if the answer was new, otherwise it fails.
+  trie_insert(AnswerTrie,A2,A2), % Use answer both as key and as value. Having it as value uses memory, but greatly simplifies getting all the answers.
+  % We got here, so trie_insert added a new answer.
+  % We must also insert this answer in the worklist
+  wkl_add_answer(Worklist,A2),
+  bb_put(NbWorklistID, table_nb_worklist(Worklist)),
+  bb_put(NbAnswerTrieID, table_nb_answer_trie(AnswerTrie)).
+
+get_answer(TableIdentifier,A) :-
+  p_get_table_for_identifier(TableIdentifier,Table),
+  get_answer_trie_(Table,AnswerTrie),
+  % The trick is that we have stored the answers as values of the trie and that there is a method to get all the values.
+  trie_get_all_values(AnswerTrie,A).
+
+% get_answer_trie_(TableOrCompleteTable,AnswerTrie).
+% First argument is not a TableIdentifier.
+get_answer_trie_(table(_CallVariant,_Status,_NbWorklistID, NbAnswerTrieID),AnswerTrie) :-
+  bb_get(NbAnswerTrieID, table_nb_answer_trie(AnswerTrie)).
+get_answer_trie_(complete_table(_CallVariant,_NbWorklistID, NbAnswerTrieID),AnswerTrie) :-
+  bb_get(NbAnswerTrieID, table_nb_answer_trie(AnswerTrie)).
+
+get_nb_identifiers(table(_CallVariant, _Status, NbWorklistID, NbAnswerTrieID), NbWorklistID, NbAnswerTrieID).
+get_nb_identifiers(complete_table(_CallVariant, NbWorklistID, NbAnswerTrieID), NbWorklistID, NbAnswerTrieID).
+
+% Get a list of answers for the given call variant.
+% Used in compare_expected_for_variant/3 in testlib.pl
+% IMPORTANT: table must be filled already, this is not done in this predicate! Therefore can be called during execution.
+% V = variant
+% LA = list of answers.
+%
+% More costly operation than directly giving the table identifier.
+answers_for_variant(V,LA) :-
+  table_for_variant(V,TableIdentifier),
+  p_get_table_for_identifier(TableIdentifier,Table),
+  get_answer_trie_(Table,AnswerTrie),
+  findall(Value,trie_get_all_values(AnswerTrie,Value),LA).
+
+% Set status of table TableIdentifier to active
+set_active_status(TableIdentifier) :-
+  tbd_status_transition(TableIdentifier,active,fresh,'set_active_status').
+
+cleanup_after_complete(TableIdentifier) :-
+  p_get_table_for_identifier(TableIdentifier,Table),
+  cleanup_after_complete_(Table,TableIdentifier).
+
+% Clause for a (noncomplete) table.
+cleanup_after_complete_(
+    table(CallVariant,_ActualOldStatus, NbWorklistID, NbAnswerTrieID),
+    TableIdentifier
+  ) :-
+  bb_put(TableIdentifier,complete_table(CallVariant, NbWorklistID, NbAnswerTrieID)).
+% If necessary for debugging add second clause for complete_table.
+
+% Set status of table TableIdentifier to complete.
+set_complete_status(TableIdentifier) :-
+  % The transition must be active to complete, otherwise we have an invalid status transition.
+  % Preexisting tables should have been cleaned-up, thus not have the form table/5 anymore, thus complete -> complete is not possible there.
+  p_get_table_for_identifier(TableIdentifier,Table),
+  set_complete_status_(Table,TableIdentifier).
+
+% set_complete_status_(Table,TableIdentifier).
+set_complete_status_(table(_CallVariant,_OldStatus,_NbWorklistID, _NbAnswerTrieID),TableIdentifier) :-
+  tbd_status_transition(TableIdentifier,complete,active,'set_complete_status').
+
+tbd_status_transition_no_check(TableIdentifier,NewStatus) :-
+  p_get_table_for_identifier(TableIdentifier,Table),
+  tbd_status_transition_no_check_(TableIdentifier,Table,NewStatus).
+
+tbd_status_transition_no_check_(TableIdentifier,Table,NewStatus) :-
+    Table = table(_,StatusFlag,_,_),
+    put_atts(StatusFlag, table_status(NewStatus)),
+    bb_put(TableIdentifier, Table).
+
+% Set Table's status to NewStatus if current status is RequiredOldStatus, otherwise throw an exception mentioning CallerAsString: attempt to set NewStatus for table TableIdentifier, but current status was ActualOldStatus instead of RequiredOldStatus
+tbd_status_transition(TableIdentifier,NewStatus,_RequiredOldStatus,_CallerAsString) :-
+  p_get_table_for_identifier(TableIdentifier,Table),
+  tbd_status_transition_no_check_(TableIdentifier,Table,NewStatus).
+
+store_dependency(TableIdentifier,Suspension) :-
+  p_get_table_for_identifier(TableIdentifier, Table),
+  get_nb_identifiers(Table, NbWorklistID, _NbAnswerTrieID),
+  copy_term(Suspension, SuspensionCopy),
+  bb_get(NbWorklistID, table_nb_worklist(Worklist)),
+  wkl_add_suspension(Worklist, SuspensionCopy),
+  bb_put(NbWorklistID, table_nb_worklist(Worklist)).

src/prolog/lib/tabling/table_link_manager.pl

@@ -0,0 +1,123 @@
+/*  Part of SWI-Prolog
+
+    Author:        Benoit Desouter <Benoit.Desouter@UGent.be>
+		   Jan Wielemaker (SWI-Prolog port)
+    Copyright (c)  2016, Benoit Desouter
+    All rights reserved.
+
+    Ported to Scryer Prolog by Mark Thom (2019/2020).
+
+    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(table_link_manager,
+	  [ get_existing_tables/1,		% -Tables
+	    p_existing_table/2,			% +Variant, -TableID
+	    p_link_variant_identifier/2,	% +Variant, -TableID
+	    num_tables/1,			% -Count
+	    get_trie_table_link/1,               % -Trie
+	    put_new_trie_table_link/0
+	  ]).
+
+:- use_module(library(atts)).
+:- use_module(library(lists)).
+:- use_module(library(iso_ext)).
+:- use_module(library(terms)).
+
+:- use_module(trie).
+
+:- attribute trie_table_link/1.
+
+% This file defines a call pattern trie.
+%
+% This data structure keeps the relation between a variant and the
+% corresponding table identifier using a trie. The trick is to make a
+% canonical representation of a given variant using the numbervars/3
+% predicate. The trie uses this canonical representation as key, and
+% the table identifier as value.
+
+% Uses the (private) global variable trie_table_link
+
+% This predicate should be called exactly once.
+% It throws an exception if it is called more than once.
+
+%%	table_link_manager_initialize
+%
+%	Initializes the global  variables   `trie_table_link`.  Normally
+%	called from table_datastructure_initialize/0.
+
+put_new_trie_table_link :-
+    (  bb_get(trie_table_link_initialized, _) ->
+       true
+    ;  trie_new(Trie),
+       put_atts(TrieFlag, trie_table_link(Trie)),
+       bb_put(trie_table_link, TrieFlag),
+       bb_put(trie_table_link_initialized, [])
+    ).
+
+get_trie_table_link(Trie) :-
+    bb_get(trie_table_link, TrieFlag),
+    get_atts(TrieFlag, trie_table_link(Trie)).
+
+% PRIVATE
+% mode: + -
+% Variant is not modified
+variant_canonical_representation(Variant, CanonicalRepresentation) :-
+    copy_term(Variant, CanonicalRepresentation),
+    numbervars(CanonicalRepresentation, 0 ,_).
+
+% Succeeds if there is a table TableIdentifier in existance for the
+% given call variant Variant.
+p_existing_table(Variant, TableIdentifier) :-
+    get_trie_table_link(Trie),
+    variant_canonical_representation(Variant, CanonicalRepresentation),
+    trie_lookup(Trie, CanonicalRepresentation,  TableIdentifier).
+
+% Important remark: we cannot use an out-of-the-box association list,
+% because we need a lookup based on variant checking, which is not
+% available for such lists. Converting the association list to a
+% regular list => why would you use an association list in the first
+% place...
+p_link_variant_identifier(Variant, TableIdentifier) :-
+    get_trie_table_link(Trie),
+    variant_canonical_representation(Variant, CanonicalRepresentation),
+    trie_insert_succeed(Trie, CanonicalRepresentation, TableIdentifier),
+    put_atts(TrieFlag, trie_table_link(Trie)),
+    bb_put(trie_table_link, TrieFlag).
+
+% Returns a list of existing table identifiers.
+% Rather costly.
+get_existing_tables(Ts) :-
+    get_trie_table_link(Trie),
+    findall(T, trie_get_all_values(Trie, T), Ts).
+
+% A very unefficient way of implementing this predicate. But it is
+% only used for unit testing, so it doesn't really matter.  Also, it
+% doesn't require any additional bookkeeping during the actual
+% execution.
+num_tables(N) :-
+    get_existing_tables(Ts),
+    length(Ts, N).

src/prolog/lib/tabling/trie.pl

@@ -0,0 +1,225 @@
+/*  Part of SWI-Prolog
+
+    Author:        Benoit Desouter <Benoit.Desouter@UGent.be>
+		   Jan Wielemaker (SWI-Prolog port)
+    Copyright (c)  2016, Benoit Desouter
+    All rights reserved.
+
+    Ported to Scryer Prolog by Mark Thom (2019/2020).
+
+    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(trie,
+	  [ trie_new/1,				% -Trie
+	    trie_insert/3,			% !Trie, +Key, +Value
+	    trie_insert_succeed/3,
+	    trie_lookup/3,			% +Trie, +Key, -Value
+	    trie_get_all_values/2		% +Trie, -Value
+	  ]).
+
+:- use_module(library(assoc)).
+:- use_module(library(atts)).
+:- use_module(library(lists)).
+
+:- attribute maybe_just/1, children/1.
+
+% Implementation of a prefix tree, a.k.a. trie %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Desired complexity for lookup and insert: linear in the length of the key.
+
+% ATTENTION: do not use the term functor_data/2; this is used internally here.
+
+% Inspiration from http://en.wikipedia.org/wiki/Trie
+
+% Structure of tries:
+% trie_inner_node(MaybeValue,Children).
+% where Children is an association list of nonvars to tries.
+% and where MaybeValue is maybe_none/0 or maybe_just(Value).
+
+% PRIVATE
+% For a term of the form p(a,q(b)), "returns" functor_data(p,2) and [a,q(b)].
+% p_trie_arity_univ(+Term,-FunctorData,-ArgumentsList).
+p_trie_arity_univ(Term,functor_data(Name,Arity),Arguments) :-
+  (  var(Term) ->
+     Name = var,
+     Arity = 0,
+     Arguments = []
+  ;  Term =.. [Name|Arguments],
+     functor(Term,_,Arity)
+  ).
+
+% Returns a new empty trie.
+trie_new(Trie) :-
+  empty_assoc(Assoc),
+  put_atts(A, children(Assoc)),
+  Trie = trie_inner_node(_,A).
+
+% Succeeds if given trie does not contain any key-value pair.
+% trie_is_empty(+Trie)
+trie_is_empty(trie_inner_node(X,A)) :-
+  get_atts(X, -maybe_just(_)),
+  get_atts(A, children(Assoc)),
+  empty_assoc(Assoc).
+
+% For internal use.
+% For now, Children is an association list that can be manipulated using the assoc_ predicates.
+trie_get_children(trie_inner_node(_,ChildNode),Children) :-
+  get_atts(ChildNode, children(Children)).
+
+% For internal use.
+trie_get_maybe_value(trie_inner_node(MaybeNode,_),MaybeValue) :-
+  get_atts(MaybeNode, maybe_just(MaybeValue)).
+
+% Destructive update of the association list Children.
+% For internal use.
+trie_set_children(trie_inner_node(_,ChildNode),Children) :-
+  put_atts(ChildNode, children(Children)).
+
+trie_set_maybe_value(trie_inner_node(MaybeNode, _),MaybeValue) :-
+  put_atts(MaybeNode, MaybeValue).
+
+trie_insert_succeed(Trie,Key,Value) :-
+  ( trie_insert(Trie,Key,Value) ->
+    true
+  ;
+    true
+  ).
+
+% Succeeds if the term was not present, fails if the term was present.
+% The term will be present now, whatever the outcome.
+% We don't use an extra argument to indicate earlier presence, as this increases the trail size.
+trie_insert(Trie,Key,Value) :-
+  p_trie_arity_univ(Key,FunctorData,KeyList),
+  trie_insert_1(KeyList,FunctorData,Trie,Value).
+
+trie_insert_1([],FunctorData,Trie,Value) :-
+  trie_get_children(Trie,Assoc),
+  % You need Assoc twice: once to traverse through it, once keeping it as a whole for insertion using put_assoc/4.
+  trie_insert_a(Assoc,Assoc,FunctorData,Trie,Value).
+
+% Inline the failure and success continuation to avoid a growing trail stack.
+trie_insert_1([First|Rest],FunctorData,Trie,Value) :-
+  trie_get_children(Trie,Assoc),
+  % You need Assoc twice: once to traverse through it, once keeping it as a whole for insertion using put_assoc/4.
+  trie_insert_1_1(Assoc,Assoc,FunctorData,Trie,First,Rest,Value).
+
+% Else part, base case: empty assoc list.
+trie_insert_a(t,Assoc,FunctorData,Trie,Value) :-
+  trie_new(Subtrie),
+  trie_set_maybe_value(Subtrie,maybe_just(Value)),
+  put_assoc(FunctorData,Assoc,Subtrie,NewAssoc),
+  trie_set_children(Trie,NewAssoc).
+
+% Then part, nonempty assoc tree.
+trie_insert_a(t(K,V,_,L,R),Assoc,FunctorData,Trie,Value) :-
+  compare(Rel,FunctorData,K),
+  trie_insert_b(Rel,V,L,R,Assoc,FunctorData,Trie,Value).
+
+% Recursively look in the left part of the assoc tree.
+trie_insert_b(<,_V,L,_R,Assoc,FunctorData,Trie,Value) :-
+  trie_insert_a(L,Assoc,FunctorData,Trie,Value).
+
+% Recursively look in the right part of the assoc tree.
+trie_insert_b(>,_V,_L,R,Assoc,FunctorData,Trie,Value) :-
+  trie_insert_a(R,Assoc,FunctorData,Trie,Value).
+
+trie_insert_b(=,V,_L,_R,_Assoc,_FunctorData,_Trie,Value) :-
+  trie_get_maybe_value(V,MaybeValue), % V is the Subtrie
+  ( MaybeValue == maybe_none ->
+    trie_set_maybe_value(V,maybe_just(Value))
+    % Use true to indicate that the answer was new.
+  ;
+    MaybeValue = maybe_just(JustValue),
+    ( JustValue == Value ->
+  	% Fail to indicate earlier presence
+  	fail
+    ;
+      throw('trie: attempt to update the value for a key')
+    )
+  ).
+
+% Else part, base case: empty assoc list
+trie_insert_1_1(t,Assoc,FunctorData,Trie,First,Rest,Value) :-
+  % Assoc = t, % t is the empty assoc tree
+  trie_new(Subtrie),
+  put_assoc(FunctorData,Assoc,Subtrie,NewAssoc),
+  trie_set_children(Trie,NewAssoc),
+  trie_insert_2(First,Rest,Subtrie,Value).
+
+% Then part, lookup in assoc list.
+trie_insert_1_1(t(K,V,_,L,R),Assoc,FunctorData,Trie,First,Rest,Value) :-
+  compare(Rel,FunctorData,K),
+  trie_insert_1_1_1(Rel,V,L,R,Assoc,FunctorData,Trie,First,Rest,Value).
+
+trie_insert_1_1_1(=,V,_L,_R,_Assoc,_FunctorData,_Trie,First,Rest,Value) :-
+  trie_insert_2(First,Rest,V,Value). % V is the Subtrie
+
+trie_insert_1_1_1(<,_V,L,_R,Assoc,FunctorData,Trie,First,Rest,Value) :-
+  % Look in the left part of the assoc tree.
+  trie_insert_1_1(L,Assoc,FunctorData,Trie,First,Rest,Value).
+
+trie_insert_1_1_1(>,_V,_L,R,Assoc,FunctorData,Trie,First,Rest,Value) :-
+  % Look in the right part of the assoc tree.
+  trie_insert_1_1(R,Assoc,FunctorData,Trie,First,Rest,Value).
+
+trie_insert_2(RegularTerm,Rest,Trie,Value) :-
+  p_trie_arity_univ(RegularTerm,FunctorData,KList),
+  append(KList,Rest,KList2),
+  trie_insert_1(KList2,FunctorData,Trie,Value).
+
+trie_lookup(Trie,Key,Value) :-
+  p_trie_arity_univ(Key,FunctorData,KeyList),
+  trie_lookup_1(FunctorData,KeyList,Trie,Value).
+
+trie_lookup_1(FunctorData,Rest,Trie,Value) :-
+  % Select right subtree, fail if it isn't there, and do recursive call.
+  trie_get_children(Trie,Assoc),
+  get_assoc(FunctorData,Assoc,Subtrie), % Fails if not present
+  trie_lookup_2(Rest,Subtrie,Value).
+
+trie_lookup_2([],Trie,Value) :-
+  % If the value at this trie is maybe_just(X), then X is our Value.
+  % Otherwise, there is no value for this key, so we fail...
+  trie_get_maybe_value(Trie,Value).
+% Regular term at the head, like p or p(a). Not functor_data/2.
+trie_lookup_2([RegularTerm|Rest],Trie,Value) :-
+  % split RegularTerm
+  p_trie_arity_univ(RegularTerm,FunctorData,KList),
+  % Make a recursive call on KList ++ Rest.
+  % Since we cannot implement p_trie_arity_univ so that "its result", KList, has a free variable at the end, without resorting to techniques that require linear time, we need a call to append/3. However, since KList will in general be rather short, I don't expect this to be a large problem in practice.
+  append(KList,Rest,KList2),
+  trie_lookup_1(FunctorData,KList2,Trie,Value).
+
+
+% Returns all values in the trie by backtracking - we don't provide any information about the associated key.
+trie_get_all_values(Trie,Value) :-
+  trie_get_maybe_value(Trie,Value).
+trie_get_all_values(Trie,Value) :-
+  trie_get_children(Trie,Children),
+  gen_assoc(_Key, Children, ChildTrie),
+  trie_get_all_values(ChildTrie,Value).

src/prolog/lib/tabling/wrapper.pl

@@ -0,0 +1,118 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    Copyright (c)  2016, VU University Amsterdam
+    All rights reserved.
+
+    Ported to Scryer Prolog by Mark Thom (2019/2020).
+
+    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(table_wrapper,
+	  [ %(table)/1,			% +Predicates
+	    op(1150, fx, table)
+	  ]).
+
+:- use_module(library(dcgs)).
+:- use_module(library(error)).
+
+%%:- multifile
+%%	system:term_expansion/2,
+%%	tabled/2.
+%%:- dynamic
+%%	system:term_expansion/2.
+
+%%	table(+PredicateIndicators)
+%
+%	Prepare the given PredicateIndicators for tabling.  Can only
+%	be used as a directive.
+
+%% table(PIList) :-
+%% 	throw(error(context_error(nodirective, table(PIList)), _)).
+
+instantiation_error(Var) :-
+        throw(error(instantiation_error(Var), _)).
+
+wrappers(Var) -->
+	{ var(Var), !,
+	  instantiation_error(Var)
+	}.
+wrappers((A,B)) --> !,
+	wrappers(A),
+	wrappers(B).
+wrappers(Name//Arity) -->
+	{ atom(Name), integer(Arity), Arity >= 0, !,
+	  Arity1 is Arity+2
+	},
+	wrappers(Name/Arity1).
+wrappers(Name/Arity) -->
+	{ atom(Name), integer(Arity), Arity >= 0, !,
+	  functor(Head, Name, Arity),
+	  atom_concat(Name, ' tabled', WrapName),
+	  Head =.. [Name|Args],
+	  WrappedHead =.. [WrapName|Args],
+	  '$module_of'(Module, Name) %prolog_load_context(module, Module)
+	},
+	[ (   Head :-
+		 start_tabling(Module:Head, WrappedHead)
+	  ),
+	  (:- multifile(table_wrapper:tabled/2)),
+	  table_wrapper:tabled(Head, Module)
+	].
+
+rename(M:Term0, M:Term, _) :-
+	atom(M), !,
+	rename(Term0, Term, M).
+rename((Head :- Body), (NewHead :- Body), Module) :- !,
+	rename(Head, NewHead, Module).
+rename((Head --> Body), (NewHead --> Body), Module) :- !,
+	functor(Head, Name, Arity),
+	PlainArity is Arity+1,
+	functor(PlainHead, Name, PlainArity),
+	table_wrapper:tabled(PlainHead, Module),
+	rename_term(Head, NewHead).
+rename(Head, NewHead, Module) :-
+	table_wrapper:tabled(Head, Module), !,
+	rename_term(Head, NewHead).
+
+rename_term(Compound0, Compound) :-
+	compound(Compound0), !,
+	Compound0 =.. [Name|Args],
+	atom_concat(Name, ' tabled', WrapName),
+	Compound =.. [WrapName|Args].
+rename_term(Name, WrapName) :-
+	atom_concat(Name, ' tabled', WrapName).
+
+
+user:term_expansion(Term0, Clauses) :-
+        nonvar(Term0),
+	Term0 = (:- table Preds),
+	phrase(wrappers(Preds), Clauses).
+user:term_expansion(Clause, NewClause) :-
+        nonvar(Clause),
+	'$module_of'(Module, Clause),
+	rename(Clause, NewClause, Module).

src/prolog/machine/and_stack.rs

@@ -1,102 +0,0 @@
-use crate::prolog::machine::machine_indices::*;
-
-use std::mem;
-use std::ops::{Index, IndexMut};
-use std::vec::Vec;
-
-#[derive(Clone)]
-pub struct Frame {
-    pub global_index: usize,
-    pub e: usize,
-    pub cp: LocalCodePtr,
-    pub interrupt_cp: LocalCodePtr,
-    perms: Vec<Addr>,
-}
-
-impl Frame {
-    fn new(global_index: usize, fr: usize, e: usize, cp: LocalCodePtr, n: usize) -> Self {
-        Frame {
-            global_index,
-            e: e,
-            cp: cp,
-            interrupt_cp: LocalCodePtr::default(),
-            perms: (1..n + 1).map(|i| Addr::StackCell(fr, i)).collect(),
-        }
-    }
-
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.perms.len()
-    }
-}
-
-pub struct AndStack(Vec<Frame>);
-
-impl AndStack {
-    pub fn new() -> Self {
-        AndStack(Vec::new())
-    }
-
-    #[inline]
-    pub(crate) fn take(&mut self) -> Self {
-        AndStack(mem::replace(&mut self.0, vec![]))
-    }
-
-    pub fn push(&mut self, global_index: usize, e: usize, cp: LocalCodePtr, n: usize) {
-        let len = self.0.len();
-        self.0.push(Frame::new(global_index, len, e, cp, n));
-    }
-
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    pub fn clear(&mut self) {
-        self.0.clear()
-    }
-
-    pub fn resize(&mut self, fr: usize, n: usize) {
-        let len = self[fr].perms.len();
-
-        if len < n {
-            self[fr].perms.reserve(n - len);
-
-            for i in len..n {
-                self[fr].perms.push(Addr::StackCell(fr, i));
-            }
-        }
-    }
-
-    #[inline]
-    pub fn truncate(&mut self, len: usize) {
-        self.0.truncate(len);
-    }
-}
-
-impl Index<usize> for AndStack {
-    type Output = Frame;
-
-    fn index(&self, index: usize) -> &Self::Output {
-        self.0.index(index)
-    }
-}
-
-impl IndexMut<usize> for AndStack {
-    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
-        self.0.index_mut(index)
-    }
-}
-
-impl Index<usize> for Frame {
-    type Output = Addr;
-
-    fn index(&self, index: usize) -> &Self::Output {
-        self.perms.index(index - 1)
-    }
-}
-
-impl IndexMut<usize> for Frame {
-    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
-        self.perms.index_mut(index - 1)
-    }
-}

src/prolog/machine/attributed_variables.pl

@@ -1,6 +1,5 @@
 driver(Vars, Values) :-
     iterate(Vars, Values, ListOfListsOfGoalLists),
-    '$redo_attr_var_bindings', % the bindings list is emptied here.
     !,
     call_goals(ListOfListsOfGoalLists),
     '$return_from_verify_attr'.
@@ -8,6 +7,7 @@ driver(Vars, Values) :-
 iterate([Var|VarBindings], [Value|ValueBindings], [ListOfGoalLists | ListsCubed]) :-
     '$get_attr_list'(Var, Ls),
     call_verify_attributes(Ls, Var, Value, ListOfGoalLists),
+    '$redo_attr_var_binding'(Var, Value),
     iterate(VarBindings, ValueBindings, ListsCubed).
 iterate([], [], []).
 
@@ -16,6 +16,14 @@ gather_modules([Attr|Attrs], [Module|Modules]) :-
     '$module_of'(Module, Attr),  % write the owning module of Attr to Module.
     gather_modules(Attrs, Modules).
 
+call_verify_attributes(Attrs, _, _, []) :-
+    var(Attrs), !.
+call_verify_attributes([], _, _, []).
+call_verify_attributes([Attr|Attrs], Var, Value, ListOfGoalLists) :-
+    gather_modules([Attr|Attrs], Modules0),
+    sort(Modules0, Modules),
+    verify_attrs(Modules, Var, Value, ListOfGoalLists).
+
 verify_attrs([Module|Modules], Var, Value, [Goals|ListOfGoalLists]) :-
     catch(Module:verify_attributes(Var, Value, Goals),
           error(evaluation_error((Module:verify_attributes)/3), verify_attributes/3),
@@ -23,13 +31,6 @@ verify_attrs([Module|Modules], Var, Value, [Goals|ListOfGoalLists]) :-
     verify_attrs(Modules, Var, Value, ListOfGoalLists).
 verify_attrs([], _, _, []).
 
-call_verify_attributes(Attrs, _, _, []) :-
-    var(Attrs), !.
-call_verify_attributes([Attr|Attrs], Var, Value, ListOfGoalLists) :-
-    gather_modules([Attr|Attrs], Modules0),
-    sort(Modules0, Modules),
-    verify_attrs(Modules, Var, Value, ListOfGoalLists).
-
 call_goals([ListOfGoalLists | ListsCubed]) :-
     call_goals_0(ListOfGoalLists),
     call_goals(ListsCubed).

src/prolog/machine/attributed_variables.rs

@@ -1,7 +1,6 @@
 use crate::prolog::machine::*;
 
-use indexmap::IndexSet;
-
+use std::cmp::Ordering;
 use std::vec::IntoIter;
 
 pub static VERIFY_ATTRS: &str = include_str!("attributed_variables.pl");
@@ -14,16 +13,19 @@ pub(super) struct AttrVarInitializer {
     pub(super) attr_var_queue: Vec<usize>,
     pub(super) bindings: Bindings,
     pub(super) cp: LocalCodePtr,
+    pub(super) instigating_p: LocalCodePtr,
     pub(super) verify_attrs_loc: usize,
     pub(super) project_attrs_loc: usize,
 }
 
 impl AttrVarInitializer {
-    pub(super) fn new(verify_attrs_loc: usize, project_attrs_loc: usize) -> Self {
+    pub(super)
+    fn new(verify_attrs_loc: usize, project_attrs_loc: usize) -> Self {
         AttrVarInitializer {
             attribute_goals: vec![],
             attr_var_queue: vec![],
             bindings: vec![],
+            instigating_p: LocalCodePtr::default(),
             cp: LocalCodePtr::default(),
             verify_attrs_loc,
             project_attrs_loc,
@@ -31,22 +33,33 @@ impl AttrVarInitializer {
     }
 
     #[inline]
-    pub(super) fn reset(&mut self) {
+    pub(super)
+    fn reset(&mut self) {
+	    self.attribute_goals.clear();
         self.attr_var_queue.clear();
         self.bindings.clear();
-	self.attribute_goals.clear();
+    }
+
+    #[inline]
+    pub(super)
+    fn backtrack(&mut self, queue_b: usize, bindings_b: usize) {
+        self.attr_var_queue.truncate(queue_b);
+        self.bindings.truncate(bindings_b);
     }
 }
 
 impl MachineState {
-    pub(super) fn push_attr_var_binding(&mut self, h: usize, addr: Addr) {
+    pub(super)
+    fn push_attr_var_binding(&mut self, h: usize, addr: Addr) {
         if self.attr_var_init.bindings.is_empty() {
+            self.attr_var_init.instigating_p = self.p.local();
+
             if self.last_call {
                 self.attr_var_init.cp = self.cp;
             } else {
-                self.attr_var_init.cp = self.p.local();
+                self.attr_var_init.cp = self.p.local() + 1;
             }
-            
+
             self.p = CodePtr::VerifyAttrInterrupt(self.attr_var_init.verify_attrs_loc);
         }
 
@@ -58,16 +71,17 @@ impl MachineState {
             .attr_var_init
             .bindings
             .iter()
-            .map(|(ref h, _)| Addr::AttrVar(*h));
+            .map(|(ref h, _)| HeapCellValue::Addr(Addr::AttrVar(*h)));
+
         let var_list_addr = Addr::HeapCell(self.heap.to_list(iter));
 
         let iter = self
             .attr_var_init
             .bindings
-            .iter()
-            .map(|(_, ref addr)| addr.clone());
-        let value_list_addr = Addr::HeapCell(self.heap.to_list(iter));
+            .drain(0 ..)
+            .map(|(_, addr)| HeapCellValue::Addr(addr));
 
+        let value_list_addr = Addr::HeapCell(self.heap.to_list(iter));
         (var_list_addr, value_list_addr)
     }
 
@@ -82,7 +96,8 @@ impl MachineState {
         self[temp_v!(2)] = value_list_addr;
     }
 
-    pub(super) fn gather_attr_vars_created_since(&self, b: usize) -> IntoIter<Addr> {
+    pub(super)
+    fn gather_attr_vars_created_since(&self, b: usize) -> IntoIter<Addr> {
         let mut attr_vars: Vec<_> = self.attr_var_init.attr_var_queue[b..]
             .iter()
             .filter_map(|h| match self.store(self.deref(Addr::HeapCell(*h))) {
@@ -91,60 +106,29 @@ impl MachineState {
             })
             .collect();
 
-        attr_vars.sort_unstable_by(|a1, a2| self.compare_term_test(a1, a2));
+        attr_vars.sort_unstable_by(|a1, a2| {
+            self.compare_term_test(a1, a2).unwrap_or(Ordering::Less)
+        });
 
         self.term_dedup(&mut attr_vars);
         attr_vars.into_iter()
     }
 
-    fn populate_project_attr_lists(&mut self) -> (Addr, Addr) {
-        let mut query_vars = IndexSet::new();
-        let attr_vars = self.gather_attr_vars_created_since(0);
-
-        for (_, addr) in self.heap_locs.iter() {
-            let iter = self.acyclic_pre_order_iter(addr.clone());
-
-            for value in iter {
-                match value {
-                    HeapCellValue::Addr(Addr::HeapCell(h)) => {
-                        query_vars.insert(Addr::HeapCell(h));
-                    }
-                    HeapCellValue::Addr(Addr::StackCell(fr, sc)) => {
-                        query_vars.insert(Addr::StackCell(fr, sc));
-                    }
-                    HeapCellValue::Addr(Addr::AttrVar(h)) => {
-                        query_vars.insert(Addr::AttrVar(h));
-                    }
-                    _ => {}
-                };
-            }
-        }
-
-        let query_var_list = Addr::HeapCell(self.heap.to_list(query_vars.into_iter()));
-        let attr_var_list = Addr::HeapCell(self.heap.to_list(attr_vars));
-
-        (query_var_list, attr_var_list)
-    }
-
-    pub(super) fn verify_attr_interrupt(&mut self, p: usize) {
-        let rs = MAX_ARITY;
-
-        // store temp vars in perm vars slots along with self.b0 and
-        // self.num_of_args. why self.b0? if we return to a NeckCut
-        // after finishing the interrupt, it won't work correctly if
-        // self.b == self.b0. we must change it back when we return,
-        // as if nothing happened.
-        self.allocate(rs + 2);
+    pub(super)
+    fn verify_attr_interrupt(&mut self, p: usize) {
+        self.allocate(self.num_of_args + 2);
 
         let e = self.e;
-        self.and_stack[e].interrupt_cp = self.attr_var_init.cp;
+        self.stack.index_and_frame_mut(e).prelude.interrupt_cp = self.attr_var_init.cp;
 
-        for i in 1..rs + 1 {
-            self.and_stack[e][i] = self[RegType::Temp(i)].clone();
+        for i in 1 .. self.num_of_args + 1 {
+            self.stack.index_and_frame_mut(e)[i] = self[RegType::Temp(i)].clone();
         }
 
-        self.and_stack[e][rs + 1] = Addr::Con(Constant::Usize(self.b0));
-        self.and_stack[e][rs + 2] = Addr::Con(Constant::Usize(self.num_of_args));
+        self.stack.index_and_frame_mut(e)[self.num_of_args + 1] =
+            Addr::CutPoint(self.b0);
+        self.stack.index_and_frame_mut(e)[self.num_of_args + 2] =
+            Addr::Usize(self.num_of_args);
 
         self.verify_attributes();
 
@@ -152,57 +136,4 @@ impl MachineState {
         self.b0 = self.b;
         self.p = CodePtr::Local(LocalCodePtr::DirEntry(p));
     }
-
-    fn print_attribute_goals_string(&mut self, op_dir: &OpDir) -> String {
-        let mut attr_goals = mem::replace(&mut self.attr_var_init.attribute_goals, vec![]);
-
-        if attr_goals.is_empty() {
-            return String::from("");
-        }
-
-        attr_goals.sort_unstable_by(|a1, a2| self.compare_term_test(a1, a2));
-        self.term_dedup(&mut attr_goals);
-
-        let mut output = PrinterOutputter::new();
-
-        for goal_addr in attr_goals {
-            let mut printer = HCPrinter::from_heap_locs(&self, op_dir, output);
-            printer.see_all_locs();
-
-            printer.numbervars = false;
-            printer.quoted = true;
-
-            output = printer.print(goal_addr);
-            output.append(", ");
-        }
-
-        // cut trailing ", "
-        let output_len = output.len();
-        output.truncate(output_len - 2);
-
-        output.result()
-    }
-}
-
-impl Machine {
-    pub fn attribute_goals(&mut self) -> String {
-        let p = self.machine_st.attr_var_init.project_attrs_loc;
-        let (query_vars, attr_vars) = self.machine_st.populate_project_attr_lists();
-
-        self.machine_st.allocate(0);
-
-        self.machine_st[temp_v!(1)] = query_vars;
-        self.machine_st[temp_v!(2)] = attr_vars;
-
-        self.machine_st.p = CodePtr::Local(LocalCodePtr::DirEntry(p));
-        self.machine_st.query_stepper(
-            &mut self.indices,
-            &mut self.policies,
-            &mut self.code_repo,
-            &mut readline::input_stream(),
-        );
-
-        self.machine_st
-            .print_attribute_goals_string(&self.indices.op_dir)
-    }
 }

src/prolog/machine/code_repo.rs

@@ -1,5 +1,3 @@
-use prolog_parser::ast::MachineFlags;
-
 use crate::prolog::clause_types::*;
 use crate::prolog::codegen::*;
 use crate::prolog::debray_allocator::*;
@@ -9,7 +7,10 @@ use crate::prolog::machine::compile::*;
 use crate::prolog::machine::machine_errors::*;
 use crate::prolog::machine::machine_indices::*;
 
+use indexmap::IndexSet;
+
 use std::collections::VecDeque;
+use std::mem;
 
 pub struct CodeRepo {
     pub(super) cached_query: Code,
@@ -59,11 +60,12 @@ impl CodeRepo {
             .unwrap_or((Predicate::new(), VecDeque::from(vec![])))
     }
 
-    pub fn add_in_situ_result(
+    pub(crate) fn add_in_situ_result(
         &mut self,
         result: &CompiledResult,
         in_situ_code_dir: &mut InSituCodeDir,
-        flags: MachineFlags,
+        in_situ_module_dir: &mut ModuleStubDir,
+        non_counted_bt_preds: &IndexSet<PredicateKey>,
     ) -> Result<(), SessionError> {
         let (ref decl, ref queue) = result;
         let (name, arity) = decl
@@ -75,17 +77,26 @@ impl CodeRepo {
             })
             .ok_or(SessionError::NamelessEntry)?;
 
+        let non_counted_bt = non_counted_bt_preds.contains(&(name.clone(), arity));
+        let module_name = name.owning_module();
+
         let p = self.in_situ_code.len();
-        in_situ_code_dir.insert((name, arity), p);
 
-        let mut cg = CodeGenerator::<DebrayAllocator>::new(true, flags);
-        // clone the decl to avoid the need to wipe its register cells later.
-        let mut decl_code = cg.compile_predicate(&decl.0.clone())?;
+        match in_situ_module_dir.get_mut(&module_name) {
+            Some(ref mut module_stub) if name.has_table(&module_stub.atom_tbl) => {
+                module_stub.in_situ_code_dir.insert((name, arity), p);
+            }
+            _ => {
+                in_situ_code_dir.insert((name, arity), p);
+            }
+        }
 
-        compile_appendix(&mut decl_code, queue, true, flags)?;
+        let mut cg = CodeGenerator::<DebrayAllocator>::new(non_counted_bt);
+        let mut decl_code = cg.compile_predicate(&decl.0)?;
 
-        self.in_situ_code.extend(decl_code.into_iter());
-        Ok(())
+        compile_appendix(&mut decl_code, queue, non_counted_bt)?;
+
+        Ok(self.in_situ_code.extend(decl_code.into_iter()))
     }
 
     #[inline]
@@ -93,6 +104,11 @@ impl CodeRepo {
         self.cached_query.len()
     }
 
+    #[inline]
+    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>(
         &'a self,
         last_call: bool,
@@ -134,7 +150,7 @@ impl CodeRepo {
                 );
                 Some(RefOrOwned::Owned(call_clause))
             }
-            &CodePtr::CallN(arity, _) => {
+            &CodePtr::CallN(arity, _, last_call) => {
                 let call_clause = call_clause!(ClauseType::CallN, arity, 0, last_call);
                 Some(RefOrOwned::Owned(call_clause))
             }

src/prolog/machine/code_walker.rs

@@ -0,0 +1,81 @@
+use crate::prolog::instructions::*;
+
+use std::collections::VecDeque;
+
+fn scan_for_trust_me(code: &Code, jmp_offsets: &mut VecDeque<usize>, after_idx: &mut usize) {
+    for (idx, instr) in code[*after_idx..].iter().enumerate() {
+        match instr {
+            &Line::Choice(ChoiceInstruction::TrustMe)
+          | &Line::IndexedChoice(IndexedChoiceInstruction::Trust(..)) => {
+                *after_idx += idx;
+                return;
+            }
+            &Line::Control(ControlInstruction::JmpBy(_, offset, ..)) => {
+                jmp_offsets.push_back(*after_idx + idx + offset)
+            }
+            _ => {}
+        }
+    }
+}
+
+fn capture_next_range(code: &Code, queue: &mut VecDeque<usize>, last_idx: &mut usize) {
+    loop {
+        match &code[*last_idx] {
+            &Line::Choice(ChoiceInstruction::TryMeElse(..))
+          | &Line::IndexedChoice(IndexedChoiceInstruction::Try(..)) => {
+                    *last_idx += 1;
+                    scan_for_trust_me(code, queue, last_idx);
+                }
+            &Line::Control(ControlInstruction::JmpBy(_, offset, _, false)) => {
+                queue.push_back(*last_idx + offset);
+                *last_idx += 1;
+            }
+            &Line::Control(ControlInstruction::JmpBy(_, offset, _, true)) => {
+                queue.push_back(*last_idx + offset);
+                break;
+            }
+            &Line::Control(ControlInstruction::Proceed)
+          | &Line::Control(ControlInstruction::CallClause(_, _, _, true, _)) =>
+                break,
+            _ =>
+                *last_idx += 1,
+        };
+    }
+}
+
+/* This function walks the code of a single predicate, supposed to
+ * begin in code at the offset p. Each instruction is passed to the
+ * walker function.
+ */
+pub fn walk_code(code: &Code, p: usize, mut walker: impl FnMut(&Line))
+{
+    let mut queue = VecDeque::from(vec![p]);
+
+    while let Some(first_idx) = queue.pop_front() {
+        let mut last_idx = first_idx;
+
+        capture_next_range(code, &mut queue, &mut last_idx);
+
+        for instr in &code[first_idx .. last_idx + 1] {
+            walker(instr);
+        }
+    }
+}
+
+/* A function for code walking that might result in modification to
+ * the code. Otherwise identical to walk_code.
+ */
+pub fn walk_code_mut(code: &mut Code, p: usize, mut walker: impl FnMut(&mut Line))
+{
+    let mut queue = VecDeque::from(vec![p]);
+
+    while let Some(first_idx) = queue.pop_front() {
+        let mut last_idx = first_idx;
+
+        capture_next_range(code, &mut queue, &mut last_idx);
+
+        for instr in &mut code[first_idx .. last_idx + 1] {
+            walker(instr);
+        }
+    }
+}

src/prolog/machine/copier.rs

@@ -1,21 +1,31 @@
-use crate::prolog::machine::and_stack::*;
 use crate::prolog::machine::machine_indices::*;
+use crate::prolog::machine::stack::*;
+use crate::prolog::machine::streams::*;
 
+use std::mem;
 use std::ops::IndexMut;
 
 type Trail = Vec<(Ref, HeapCellValue)>;
 
-pub(crate) trait CopierTarget: IndexMut<usize, Output = HeapCellValue> {
-    fn threshold(&self) -> usize;
-    fn push(&mut self, _: HeapCellValue);
-    fn store(&self, _: Addr) -> Addr;
-    fn deref(&self, _: Addr) -> Addr;
-    fn stack(&mut self) -> &mut AndStack;
+#[derive(Clone, Copy)]
+pub enum AttrVarPolicy {
+    DeepCopy,
+    StripAttributes
 }
 
-pub(crate) fn copy_term<T: CopierTarget>(target: T, addr: Addr) {
-    let mut copy_term_state = CopyTermState::new(target);
-    copy_term_state.copy_term_impl(addr);    
+pub(crate)
+trait CopierTarget: IndexMut<usize, Output = HeapCellValue> {
+    fn deref(&self, val: Addr) -> Addr;
+    fn push(&mut self, val: HeapCellValue);
+    fn stack(&mut self) -> &mut Stack;
+    fn store(&self, val: Addr) -> Addr;
+    fn threshold(&self) -> usize;
+}
+
+pub(crate)
+fn copy_term<T: CopierTarget>(target: T, addr: Addr, attr_var_policy: AttrVarPolicy) {
+    let mut copy_term_state = CopyTermState::new(target, attr_var_policy);
+    copy_term_state.copy_term_impl(addr);
 }
 
 struct CopyTermState<T: CopierTarget> {
@@ -23,15 +33,17 @@ struct CopyTermState<T: CopierTarget> {
     scan: usize,
     old_h: usize,
     target: T,
+    attr_var_policy: AttrVarPolicy,
 }
 
 impl<T: CopierTarget> CopyTermState<T> {
-    fn new(target: T) -> Self {
+    fn new(target: T, attr_var_policy: AttrVarPolicy) -> Self {
         CopyTermState {
-            trail: vec![],
+            trail: Trail::new(),
             scan: 0,
             old_h: target.threshold(),
             target,
+            attr_var_policy
         }
     }
 
@@ -41,135 +53,215 @@ impl<T: CopierTarget> CopyTermState<T> {
         &mut self.target[scan]
     }
 
-    fn reinstantiate_var(&mut self, addr: Addr, threshold: usize) {
+    fn trail_list_cell(&mut self, addr: usize, threshold: usize) {
+        let trail_item = mem::replace(
+            &mut self.target[addr],
+            HeapCellValue::Addr(Addr::Lis(threshold)),
+        );
+
+        self.trail.push((
+            Ref::HeapCell(addr),
+            trail_item,
+        ));
+    }
+
+    fn copy_list(&mut self, addr: usize) {
+        for offset in 0 .. 2 {
+            if let Addr::Lis(h) = self.target[addr + offset].as_addr(addr + offset) {
+                if h >= self.old_h {
+                    *self.value_at_scan() = HeapCellValue::Addr(Addr::Lis(h));
+                    self.scan += 1;
+
+                    return;
+                }
+            }
+        }
+
+        let threshold = self.target.threshold();
+
+        *self.value_at_scan() = HeapCellValue::Addr(Addr::Lis(threshold));
+
+        for i in 0 .. 2 {
+            let hcv = self.target[addr + i].context_free_clone();
+            self.target.push(hcv);
+        }
+
+        let cdr = self.target.store(self.target.deref(Addr::HeapCell(addr + 1)));
+
+        if !cdr.is_ref() {
+            self.trail_list_cell(addr + 1, threshold);
+        } else {
+            let car = self.target.store(self.target.deref(Addr::HeapCell(addr)));
+
+            if !car.is_ref() {
+                self.trail_list_cell(addr, threshold);
+            }
+        }
+
+        self.scan += 1;
+    }
+
+    fn copy_partial_string(&mut self, addr: usize, n: usize) {
+        if let &HeapCellValue::Addr(Addr::PStrLocation(h, _)) = &self.target[addr] {
+            if h >= self.old_h {
+                *self.value_at_scan() = HeapCellValue::Addr(Addr::PStrLocation(h, n));
+                self.scan += 1;
+
+                return;
+            }
+        }
+
+        let threshold = self.target.threshold();
+
+        *self.value_at_scan() =
+            HeapCellValue::Addr(Addr::PStrLocation(threshold, 0));
+
+        self.scan += 1;
+
+        let (pstr, has_tail) =
+            match &self.target[addr] {
+                &HeapCellValue::PartialString(ref pstr, has_tail) => {
+                    (pstr.clone_from_offset(n), has_tail)
+                }
+                _ => {
+                    unreachable!()
+                }
+            };
+
+        self.target.push(HeapCellValue::PartialString(pstr, has_tail));
+
+        let replacement = HeapCellValue::Addr(Addr::PStrLocation(threshold, 0));
+
+        let trail_item = mem::replace(
+            &mut self.target[addr],
+            replacement,
+        );
+
+        self.trail.push((
+            Ref::HeapCell(addr),
+            trail_item,
+        ));
+
+        if has_tail {
+            let tail_addr = self.target[addr + 1].as_addr(addr + 1);
+            self.target.push(HeapCellValue::Addr(tail_addr));
+        }
+    }
+
+    fn reinstantiate_var(&mut self, addr: Addr, frontier: usize) {
         match addr {
             Addr::HeapCell(h) => {
-                self.target[threshold] = HeapCellValue::Addr(Addr::HeapCell(threshold));
-                self.target[h] = HeapCellValue::Addr(Addr::HeapCell(threshold));
-                self.trail
-                    .push((Ref::HeapCell(h), HeapCellValue::Addr(Addr::HeapCell(h))));
+                self.target[frontier] = HeapCellValue::Addr(Addr::HeapCell(frontier));
+                self.target[h] = HeapCellValue::Addr(Addr::HeapCell(frontier));
+
+                self.trail.push((
+                    Ref::HeapCell(h),
+                    HeapCellValue::Addr(Addr::HeapCell(h)),
+                ));
             }
             Addr::StackCell(fr, sc) => {
-                self.target[threshold] = HeapCellValue::Addr(Addr::HeapCell(threshold));
-                self.target.stack()[fr][sc] = Addr::HeapCell(threshold);
+                self.target[frontier] = HeapCellValue::Addr(Addr::HeapCell(frontier));
+                self.target.stack().index_and_frame_mut(fr)[sc] = Addr::HeapCell(frontier);
+
                 self.trail.push((
                     Ref::StackCell(fr, sc),
                     HeapCellValue::Addr(Addr::StackCell(fr, sc)),
                 ));
             }
             Addr::AttrVar(h) => {
-                self.target[threshold] = HeapCellValue::Addr(Addr::AttrVar(threshold));
-                self.target[h] = HeapCellValue::Addr(Addr::AttrVar(threshold));
-                self.trail
-                    .push((Ref::AttrVar(h), HeapCellValue::Addr(Addr::AttrVar(h))));
-            }
-            _ => {}
-        }
-    }
-
-    fn copied_list(&mut self, addr: usize) -> bool {
-        if let HeapCellValue::Addr(Addr::Lis(addr)) = self.target[addr].clone() {
-            if addr >= self.old_h {
-                *self.value_at_scan() = HeapCellValue::Addr(Addr::Lis(addr));
-                self.scan += 1;
-                return true;
-            }
-        }
-
-        false
-    }
-
-    fn copy_list(&mut self, addr: usize) {
-        if self.copied_list(addr) {
-            return;
-        }
-
-        let threshold = self.target.threshold();
-        *self.value_at_scan() = HeapCellValue::Addr(Addr::Lis(threshold));
-
-        let hcv = self.target[addr].clone();
-        self.target.push(hcv.clone());
-
-        let ra = hcv.as_addr(threshold);
-        let rd = self.target.store(self.target.deref(ra));
-
-        match rd.clone() {
-            Addr::AttrVar(h) | Addr::HeapCell(h) if h >= self.old_h => {
-                self.target[threshold] = HeapCellValue::Addr(rd)
-            }
-            ra @ Addr::AttrVar(_) | ra @ Addr::HeapCell(..) | ra @ Addr::StackCell(..) => {
-                if ra == rd {
-                    self.reinstantiate_var(ra, threshold);
+                let threshold = if let AttrVarPolicy::DeepCopy = self.attr_var_policy {
+                    self.target.threshold()
                 } else {
-                    self.target[threshold] = HeapCellValue::Addr(ra);
+                    frontier
+                };
+
+                self.target[frontier] = HeapCellValue::Addr(Addr::HeapCell(threshold));
+                self.target[h] = HeapCellValue::Addr(Addr::HeapCell(threshold));
+
+                self.trail.push((
+                    Ref::AttrVar(h),
+                    HeapCellValue::Addr(Addr::AttrVar(h)),
+                ));
+
+                if let AttrVarPolicy::DeepCopy = self.attr_var_policy {
+                    self.target.push(HeapCellValue::Addr(Addr::AttrVar(threshold)));
+
+                    let list_val = self.target[h + 1].context_free_clone();
+                    self.target.push(list_val);
                 }
             }
             _ => {
-                self.trail
-                    .push((Ref::HeapCell(addr), self.target[addr].clone()));
-                self.target[addr] = HeapCellValue::Addr(Addr::Lis(threshold))
+                unreachable!()
             }
-        };
-
-        let hcv = self.target[addr + 1].clone();
-        self.target.push(hcv);
-
-        self.scan += 1;
+        }
     }
 
     fn copy_var(&mut self, addr: Addr) {
-        let rd = self.target.store(self.target.deref(addr.clone()));
+        let rd = self.target.store(self.target.deref(addr));
 
-        match rd.clone() {
+        match rd {
             Addr::AttrVar(h) | Addr::HeapCell(h) if h >= self.old_h => {
                 *self.value_at_scan() = HeapCellValue::Addr(rd);
                 self.scan += 1;
             }
-            Addr::AttrVar(h) if addr == rd => {
-                let threshold = self.target.threshold();
-                self.target
-                    .push(HeapCellValue::Addr(Addr::AttrVar(threshold)));
-
-                let list_val = self.target[h + 1].clone();
-                self.target.push(list_val);
-
-                self.reinstantiate_var(addr, threshold);
-                *self.value_at_scan() = HeapCellValue::Addr(Addr::AttrVar(threshold));
-            }
             _ if addr == rd => {
-                let scan = self.scan;
-                self.reinstantiate_var(addr, scan);
+                self.reinstantiate_var(addr, self.scan);
                 self.scan += 1;
             }
-            _ => *self.value_at_scan() = HeapCellValue::Addr(rd),
+            _ => {
+                *self.value_at_scan() = HeapCellValue::Addr(rd);
+            }
         }
     }
 
+    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].clone() {
+        match self.target[addr].context_free_clone() {
             HeapCellValue::NamedStr(arity, name, fixity) => {
                 let threshold = self.target.threshold();
 
                 *self.value_at_scan() = HeapCellValue::Addr(Addr::Str(threshold));
-                self.target[addr] = HeapCellValue::Addr(Addr::Str(threshold));
+
+                let trail_item = mem::replace(
+                    &mut self.target[addr],
+                    HeapCellValue::Addr(Addr::Str(threshold)),
+                );
 
                 self.trail.push((
                     Ref::HeapCell(addr),
-                    HeapCellValue::NamedStr(arity, name.clone(), fixity.clone()),
+                    trail_item,
                 ));
 
-                self.target
-                    .push(HeapCellValue::NamedStr(arity, name, fixity));
+                self.target.push(HeapCellValue::NamedStr(arity, name, fixity));
 
                 for i in 0..arity {
-                    let hcv = self.target[addr + 1 + i].clone();
+                    let hcv = self.target[addr + 1 + i].context_free_clone();
                     self.target.push(hcv);
                 }
             }
             HeapCellValue::Addr(Addr::Str(addr)) => {
                 *self.value_at_scan() = HeapCellValue::Addr(Addr::Str(addr))
             }
-            _ => {}
+            _ => {
+                unreachable!()
+            }
         }
 
         self.scan += 1;
@@ -180,16 +272,46 @@ impl<T: CopierTarget> CopyTermState<T> {
         self.target.push(HeapCellValue::Addr(addr));
 
         while self.scan < self.target.threshold() {
-            match self.value_at_scan().clone() {
-                HeapCellValue::NamedStr(..) => self.scan += 1,
-                HeapCellValue::Addr(addr) => match addr {
-                    Addr::Lis(addr) => self.copy_list(addr),
-                    addr @ Addr::AttrVar(_)
-                    | addr @ Addr::HeapCell(_)
-                    | addr @ Addr::StackCell(..) => self.copy_var(addr),
-                    Addr::Str(addr) => self.copy_structure(addr),
-                    Addr::Con(_) | Addr::DBRef(_) => self.scan += 1,
-                },
+            match self.value_at_scan() {
+                &mut HeapCellValue::Addr(addr) => {
+                    match addr {
+                        Addr::Con(h) => {
+                            let addr = self.target[h].as_addr(h);
+
+                            if addr == Addr::Con(h) {
+                                *self.value_at_scan() = self.target[h].context_free_clone();
+                            } else {
+                                *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);
+                        }
+                        addr @ Addr::AttrVar(_) |
+                        addr @ Addr::HeapCell(_) |
+                        addr @ Addr::StackCell(..) => {
+                            self.copy_var(addr);
+                        }
+                        Addr::Str(addr) => {
+                            self.copy_structure(addr);
+                        }
+                        Addr::PStrLocation(addr, n) => {
+                            self.copy_partial_string(addr, n);
+                        }
+                        Addr::Stream(h) => {
+                            self.copy_stream(h);
+                        }
+                        _ => {
+                            self.scan += 1;
+                        }
+                    }
+                }
+                _ => {
+                    self.scan += 1;
+                }
             }
         }
 
@@ -199,8 +321,10 @@ impl<T: CopierTarget> CopyTermState<T> {
     fn unwind_trail(&mut self) {
         for (r, value) in self.trail.drain(0..) {
             match r {
-                Ref::AttrVar(h) | Ref::HeapCell(h) => self.target[h] = value,
-                Ref::StackCell(fr, sc) => self.target.stack()[fr][sc] = value.as_addr(0),
+                Ref::AttrVar(h) | Ref::HeapCell(h) =>
+                    self.target[h] = value,
+                Ref::StackCell(fr, sc) =>
+                    self.target.stack().index_and_frame_mut(fr)[sc] = value.as_addr(0),
             }
         }
     }

src/prolog/machine/dynamic_database.rs

@@ -1,11 +1,12 @@
 use 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::*;
+use crate::prolog::machine::streams::*;
 
-use std::io::Read;
+use std::convert::TryFrom;
 
 impl Machine {
     pub(super) fn atom_tbl_of(&self, name: &ClauseName) -> TabledData<Atom> {
@@ -15,25 +16,23 @@ impl Machine {
         }
     }
 
-    fn compile_into_machine<R: Read>(
+    fn compile_into_machine(
         &mut self,
-        src: ParsingStream<R>,
+        src: Stream,
         name: ClauseName,
         arity: usize,
     ) -> EvalSession {
-        let user_src = clause_name!("user");
-
         match name.owning_module().as_str() {
             "user" => match self.indices.code_dir.get(&(name.clone(), arity)).cloned() {
                 Some(idx) => {
                     let module = idx.0.borrow().1.clone();
 
                     match module.as_str() {
-                        "user" => compile_user_module(self, src, true, user_src),
-                        _ => compile_into_module(self, module, src, name)                                                 
+                        "user" => compile_user_module(self, src, true, ListingSource::User),
+                        _ => compile_into_module(self, module, src, name)
                     }
                 }
-                None => compile_user_module(self, src, true, user_src),
+                None => compile_user_module(self, src, true, ListingSource::User),
             },
             _ => compile_into_module(self, name.owning_module(), src, name),
         }
@@ -44,13 +43,35 @@ impl Machine {
         let arity = self.machine_st[arity].clone();
 
         let name = match self.machine_st.store(self.machine_st.deref(name)) {
-            Addr::Con(Constant::Atom(name, _)) => name,
+            Addr::Con(h) =>
+                if let HeapCellValue::Atom(ref name, _) = &self.machine_st.heap[h] {
+                    name.clone()
+                } else {
+                    unreachable!()
+                },
             _ => unreachable!(),
         };
 
         let arity = match self.machine_st.store(self.machine_st.deref(arity)) {
-            Addr::Con(Constant::Integer(arity)) => arity.to_usize().unwrap(),
-            _ => unreachable!(),
+            Addr::Con(h) => {
+                match &self.machine_st.heap[h] {
+                    HeapCellValue::Integer(ref arity) => {
+                        arity.to_usize().unwrap()
+                    }
+                    HeapCellValue::Addr(Addr::Fixnum(arity)) => {
+                        usize::try_from(*arity).unwrap()
+                    }
+                    _ => {
+                        unreachable!()
+                    }
+                }
+            }
+            Addr::Usize(n) => {
+                n
+            }
+            _ => {
+                unreachable!()
+            }
         };
 
         (name, arity)
@@ -76,16 +97,27 @@ impl Machine {
         output.result()
     }
 
+    fn make_undefined(&mut self, name: ClauseName, arity: usize) {
+        if let Some(idx) = self.indices.code_dir.get(&(name, arity)) {
+            set_code_index!(idx, IndexPtr::DynamicUndefined, clause_name!("user"));
+        }
+    }
+
+    fn make_undefined_in_module(&mut self, module_name: ClauseName, name: ClauseName, arity: usize) {
+        if let Some(idx) = self.indices.code_dir.get(&(name, arity)) {
+            if idx.module_name() == module_name {
+                set_code_index!(idx, IndexPtr::DynamicUndefined, clause_name!("user"));
+            }
+        }
+    }
+
     fn abolish_dynamic_clause(&mut self, name: RegType, arity: RegType) {
         let (name, arity) = self.get_predicate_key(name, arity);
 
-        if let Some(idx) = self.indices.code_dir.get(&(name.clone(), arity)) {
-            set_code_index!(idx, IndexPtr::DynamicUndefined, clause_name!("user"));
-        }
+        self.make_undefined(name.clone(), arity);
 
         self.indices.remove_code_index((name.clone(), arity));
-        self.indices
-            .remove_clause_subsection(name.owning_module(), name, arity);
+        self.indices.remove_clause_subsection(name.owning_module(), name, arity);
     }
 
     fn abolish_dynamic_clause_in_module(&mut self, name: RegType, arity: RegType, module: RegType) {
@@ -93,28 +125,28 @@ impl Machine {
         let module_addr = self.machine_st[module].clone();
 
         let module_name = match self.machine_st.store(self.machine_st.deref(module_addr)) {
-            Addr::Con(Constant::Atom(module, _)) => match self.indices.modules.get_mut(&module) {
-                Some(ref mut module) => {
-                    module.code_dir.remove(&(name.clone(), arity));
-                    module.module_decl.name.clone()
-                }
-                _ => {
-                    self.machine_st.fail = true;
-                    return;
-                }
-            },
+            Addr::Con(h) =>
+                if let HeapCellValue::Atom(ref module, _) = &self.machine_st.heap[h] {
+                    match self.indices.modules.get_mut(module) {
+                        Some(ref mut module) => {
+                            module.code_dir.remove(&(name.clone(), arity));
+                            module.module_decl.name.clone()
+                        }
+                        _ => {
+                            self.machine_st.fail = true;
+                            return;
+                        }
+                    }
+                } else {
+                    unreachable!()
+                },
             _ => unreachable!(),
         };
 
-        if let Some(idx) = self.indices.code_dir.get(&(name.clone(), arity)) {
-            if idx.module_name() == module_name {
-                set_code_index!(idx, IndexPtr::DynamicUndefined, clause_name!("user"));
-            }
-        }
+        self.make_undefined_in_module(module_name.clone(), name.clone(), arity);
 
         self.indices.remove_code_index((name.clone(), arity));
-        self.indices
-            .remove_clause_subsection(module_name, name, arity);
+        self.indices.remove_clause_subsection(module_name, name, arity);
     }
 
     fn handle_eval_result_from_dynamic_compile(
@@ -126,11 +158,16 @@ impl Machine {
     ) {
         let machine_st = mem::replace(&mut self.machine_st, MachineState::new());
 
-        let result = self.compile_into_machine(parsing_stream(pred_str.as_bytes()), name, arity);
+        let result = self.compile_into_machine(
+            Stream::from(pred_str),
+            name,
+            arity,
+        );
+
         self.machine_st = machine_st;
 
         if let EvalSession::Error(err) = result {
-            let h = self.machine_st.heap.h;
+            let h = self.machine_st.heap.h();
             let stub = MachineError::functor_stub(src, 1);
             let err = MachineError::session_error(h, err);
             let err = self.machine_st.error_form(err, stub);
@@ -154,21 +191,34 @@ impl Machine {
                 place.push_to_queue(&mut addrs, added_clause);
                 self.print_new_dynamic_clause(addrs, name.clone(), arity)
             }
-            Err(err) => return self.machine_st.throw_exception(err),
+            Err(err) => {
+                return self.machine_st.throw_exception(err);
+            }
         };
 
-        self.handle_eval_result_from_dynamic_compile(pred_str, name, arity, place.predicate_name());
+        self.handle_eval_result_from_dynamic_compile(
+            pred_str,
+            name,
+            arity,
+            place.predicate_name(),
+        );
     }
 
     fn set_module_atom_tbl(&mut self, module_addr: Addr, name: &mut ClauseName) -> bool {
         let atom_tbl = match self.machine_st.store(self.machine_st.deref(module_addr)) {
-            Addr::Con(Constant::Atom(module, _)) => match self.indices.modules.get(&module) {
-                Some(ref module) => module.atom_tbl.clone(),
-                None => {
+            Addr::Con(h) =>
+                if let HeapCellValue::Atom(ref module, _) = &self.machine_st.heap[h] {
+                    match self.indices.modules.get(module) {
+                        Some(ref module) => module.atom_tbl.clone(),
+                        None => {
+                            self.machine_st.fail = true;
+                            return false;
+                        }
+                    }
+                } else {
                     self.machine_st.fail = true;
                     return false;
-                }
-            },
+                },
             _ => unreachable!(),
         };
 
@@ -196,7 +246,18 @@ impl Machine {
     fn retract_from_dynamic_predicate_in_module(&mut self) {
         let index = self.machine_st[temp_v!(3)].clone();
         let index = match self.machine_st.store(self.machine_st.deref(index)) {
-            Addr::Con(Constant::Integer(n)) => n.to_usize().unwrap(),
+            Addr::Con(h) =>
+                match &self.machine_st.heap[h] {
+                    HeapCellValue::Integer(ref arity) => {
+                        arity.to_usize().unwrap()
+                    }
+                    HeapCellValue::Addr(Addr::Fixnum(arity)) => {
+                        usize::try_from(*arity).unwrap()
+                    }
+                    _ => {
+                        unreachable!()
+                    }
+                }
             _ => unreachable!(),
         };
 
@@ -210,9 +271,15 @@ impl Machine {
                     let mut addrs = VecDeque::from(addrs);
                     addrs.remove(index);
 
+                    if addrs.is_empty() {
+                        self.make_undefined(name.clone(), arity);
+                    }
+
                     self.print_new_dynamic_clause(addrs, name.clone(), arity)
                 }
-                Err(err) => return self.machine_st.throw_exception(err),
+                Err(err) => {
+                    return self.machine_st.throw_exception(err);
+                }
             };
 
             self.handle_eval_result_from_dynamic_compile(
@@ -227,8 +294,22 @@ impl Machine {
     fn retract_from_dynamic_predicate(&mut self) {
         let index = self.machine_st[temp_v!(3)].clone();
         let index = match self.machine_st.store(self.machine_st.deref(index)) {
-            Addr::Con(Constant::Integer(n)) => n.to_usize().unwrap(),
-            _ => unreachable!(),
+            Addr::Con(h) => {
+                match &self.machine_st.heap[h] {
+                    HeapCellValue::Integer(ref arity) => {
+                        arity.to_usize().unwrap()
+                    }
+                    HeapCellValue::Addr(Addr::Fixnum(arity)) => {
+                        usize::try_from(*arity).unwrap()
+                    }
+                    _ => {
+                        unreachable!()
+                    }
+                }
+            }
+            _ => {
+                unreachable!()
+            }
         };
 
         let (name, arity) = self.get_predicate_key(temp_v!(1), temp_v!(2));
@@ -239,9 +320,15 @@ impl Machine {
                 let mut addrs = VecDeque::from(addrs);
                 addrs.remove(index);
 
+                if addrs.is_empty() {
+                    self.make_undefined(name.clone(), arity);
+                }
+
                 self.print_new_dynamic_clause(addrs, name.clone(), arity)
             }
-            Err(err) => return self.machine_st.throw_exception(err),
+            Err(err) => {
+                return self.machine_st.throw_exception(err);
+            }
         };
 
         self.handle_eval_result_from_dynamic_compile(
@@ -258,8 +345,12 @@ impl Machine {
         p: LocalCodePtr,
     ) {
         match trans_type {
-            DynamicTransactionType::Abolish => self.abolish_dynamic_clause(temp_v!(1), temp_v!(2)),
-            DynamicTransactionType::Assert(place) => self.recompile_dynamic_predicate(place),
+            DynamicTransactionType::Abolish => {
+                self.abolish_dynamic_clause(temp_v!(1), temp_v!(2))
+            }
+            DynamicTransactionType::Assert(place) => {
+                self.recompile_dynamic_predicate(place)
+            }
             DynamicTransactionType::ModuleAbolish => {
                 self.abolish_dynamic_clause_in_module(temp_v!(1), temp_v!(2), temp_v!(3))
             }
@@ -269,7 +360,9 @@ impl Machine {
             DynamicTransactionType::ModuleRetract => {
                 self.retract_from_dynamic_predicate_in_module()
             }
-            DynamicTransactionType::Retract => self.retract_from_dynamic_predicate(),
+            DynamicTransactionType::Retract => {
+                self.retract_from_dynamic_predicate()
+            }
         }
 
         self.machine_st.p = CodePtr::Local(p);

src/prolog/machine/heap.rs

@@ -1,99 +1,545 @@
-use prolog_parser::ast::*;
+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 std::convert::TryFrom;
 use std::mem;
 use std::ops::{Index, IndexMut};
+use std::ptr;
 
-pub struct Heap {
-    heap: Vec<HeapCellValue>,
-    pub h: usize,
+pub(crate) struct StandardHeapTraits {}
+
+impl RawBlockTraits for StandardHeapTraits {
+    #[inline]
+    fn init_size() -> usize {
+        256 * mem::size_of::<HeapCellValue>()
+    }
+
+    #[inline]
+    fn align() -> usize {
+        mem::align_of::<HeapCellValue>()
+    }
 }
 
-impl Heap {
-    pub fn with_capacity(cap: usize) -> Self {
-        Heap {
-            heap: Vec::with_capacity(cap),
-            h: 0,
+pub(crate) struct HeapTemplate<T: RawBlockTraits> {
+    buf: RawBlock<T>,
+    _marker: PhantomData<HeapCellValue>,
+}
+
+pub(crate) type Heap = HeapTemplate<StandardHeapTraits>;
+
+impl<T: RawBlockTraits> Drop for HeapTemplate<T> {
+    fn drop(&mut self) {
+        self.clear();
+        self.buf.deallocate();
+    }
+}
+
+pub(crate)
+struct HeapIntoIter<T: RawBlockTraits> {
+    offset: usize,
+    buf: RawBlock<T>,
+}
+
+impl<T: RawBlockTraits> Drop for HeapIntoIter<T> {
+    fn drop(&mut self) {
+        let mut heap =
+            HeapTemplate { buf: self.buf.take(), _marker: PhantomData };
+
+        heap.truncate(self.offset / mem::size_of::<HeapCellValue>());
+        heap.buf.deallocate();
+    }
+}
+
+impl<T: RawBlockTraits> Iterator for HeapIntoIter<T> {
+    type Item = HeapCellValue;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let ptr = self.buf.base as usize + self.offset;
+        self.offset += mem::size_of::<HeapCellValue>();
+
+        if ptr < self.buf.top as usize {
+            unsafe {
+                Some(ptr::read(ptr as *const HeapCellValue))
+            }
+        } else {
+            None
+        }
+    }
+}
+
+pub(crate)
+struct HeapIter<'a, T: RawBlockTraits> {
+    offset: usize,
+    buf: &'a RawBlock<T>,
+}
+
+impl<'a, T: RawBlockTraits> HeapIter<'a, T> {
+    pub(crate)
+    fn new(buf: &'a RawBlock<T>, offset: usize) -> Self {
+        HeapIter { buf, offset }
+    }
+}
+
+impl<'a, T: RawBlockTraits> Iterator for HeapIter<'a, T> {
+    type Item = &'a HeapCellValue;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let ptr = self.buf.base as usize + self.offset;
+        self.offset += mem::size_of::<HeapCellValue>();
+
+        if ptr < self.buf.top as usize {
+            unsafe {
+                Some(&*(ptr as *const _))
+            }
+        } else {
+            None
+        }
+    }
+}
+
+#[allow(dead_code)]
+pub(crate)
+fn print_heap_terms<'a, I: Iterator<Item = &'a HeapCellValue>>(heap: I, h: usize) {
+    for (index, term) in heap.enumerate() {
+        println!("{} : {}", h + index, term);
+    }
+}
+
+pub(crate)
+struct HeapIterMut<'a, T: RawBlockTraits> {
+    offset: usize,
+    buf: &'a mut RawBlock<T>,
+}
+
+impl<'a, T: RawBlockTraits> HeapIterMut<'a, T> {
+    pub(crate)
+    fn new(buf: &'a mut RawBlock<T>, offset: usize) -> Self {
+        HeapIterMut { buf, offset }
+    }
+}
+
+impl<'a, T: RawBlockTraits> Iterator for HeapIterMut<'a, T> {
+    type Item = &'a mut HeapCellValue;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let ptr = self.buf.base as usize + self.offset;
+        self.offset += mem::size_of::<HeapCellValue>();
+
+        if ptr < self.buf.top as usize {
+            unsafe {
+                Some(&mut *(ptr as *mut _))
+            }
+        } else {
+            None
+        }
+    }
+}
+
+impl<T: RawBlockTraits> HeapTemplate<T> {
+    #[inline]
+    pub(crate)
+    fn new() -> Self {
+        HeapTemplate { buf: RawBlock::new(), _marker: PhantomData }
+    }
+
+    #[inline]
+    pub(crate)
+    fn clone(&self, h: usize) -> HeapCellValue {
+        match &self[h] {
+            &HeapCellValue::Addr(addr) => {
+                HeapCellValue::Addr(addr)
+            }
+            &HeapCellValue::Atom(ref name, ref op) => {
+                HeapCellValue::Atom(name.clone(), op.clone())
+            }
+            &HeapCellValue::DBRef(ref db_ref) => {
+                HeapCellValue::DBRef(db_ref.clone())
+            }
+            &HeapCellValue::Integer(ref n) => {
+                HeapCellValue::Integer(n.clone())
+            }
+            &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::Stream(_) => {
+                HeapCellValue::Addr(Addr::Stream(h))
+            }
         }
     }
 
     #[inline]
-    pub fn push(&mut self, val: HeapCellValue) {
-        self.heap.push(val);
-        self.h += 1;
+    pub(crate)
+    fn put_complete_string(&mut self, s: &str) -> Addr {
+        let addr = self.allocate_pstr(s);
+        self.pop();
+
+        let h = self.h();
+
+        match &mut self[h - 1] {
+            &mut HeapCellValue::PartialString(_, ref mut has_tail) => {
+                *has_tail = false;
+            }
+            _ => {
+                unreachable!()
+            }
+        }
+
+        addr
     }
 
     #[inline]
-    pub(crate) fn take(&mut self) -> Self {
-        let h = self.h;
-        self.h = 0;
-
-        Heap {
-            heap: mem::replace(&mut self.heap, vec![]),
-            h,
+    pub(crate)
+    fn put_constant(&mut self, c: Constant) -> Addr {
+        match c {
+            Constant::Atom(name, op) => {
+                Addr::Con(self.push(HeapCellValue::Atom(name, op)))
+            }
+            Constant::Char(c) => {
+                Addr::Char(c)
+            }
+            Constant::CharCode(c) => {
+                Addr::CharCode(c)
+            }
+            Constant::EmptyList => {
+                Addr::EmptyList
+            }
+            Constant::Fixnum(n) => {
+                Addr::Fixnum(n)
+            }
+            Constant::Integer(n) => {
+                Addr::Con(self.push(HeapCellValue::Integer(n)))
+            }
+            Constant::Rational(r) => {
+                Addr::Con(self.push(HeapCellValue::Rational(r)))
+            }
+            Constant::Float(f) => {
+                Addr::Float(f)
+            }
+            Constant::String(s) => {
+                if s.is_empty() {
+                    Addr::EmptyList
+                } else {
+                    self.put_complete_string(&s)
+                }
+            }
+            Constant::Usize(n) => {
+                Addr::Usize(n)
+            }
         }
     }
 
     #[inline]
-    pub fn truncate(&mut self, h: usize) {
-        self.h = h;
-        self.heap.truncate(h);
+    pub(crate)
+    fn pop(&mut self) {
+        let h = self.h();
+
+        if h > 0 {
+            self.truncate(h - 1);
+        }
     }
 
     #[inline]
-    pub fn last(&self) -> Option<&HeapCellValue> {
-        self.heap.last()
+    pub(crate)
+    fn push(&mut self, val: HeapCellValue) -> usize {
+        let h = self.h();
+
+        unsafe {
+            let new_top = self.buf.new_block(mem::size_of::<HeapCellValue>());
+            ptr::write(self.buf.top as *mut _, val);
+            self.buf.top = new_top;
+        }
+
+        h
     }
 
     #[inline]
-    pub fn len(&self) -> usize {
-        self.heap.len()
+    pub(crate)
+    fn atom_at(&self, h: usize) -> bool {
+        if let HeapCellValue::Atom(..) = &self[h] {
+            true
+        } else {
+            false
+        }
     }
 
-    pub fn append(&mut self, vals: Vec<HeapCellValue>) {
-        let n = vals.len();
+    #[inline]
+    pub(crate)
+    fn to_unifiable(&mut self, non_heap_value: HeapCellValue) -> Addr {
+        match non_heap_value {
+            HeapCellValue::Addr(addr) => {
+                addr
+            }
+            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));
 
-        self.heap.extend(vals.into_iter());
-        self.h += n;
+                if has_tail {
+                    self.push(HeapCellValue::Addr(Addr::EmptyList));
+                }
+
+                Addr::Con(h)
+            }
+        }
     }
 
-    pub fn clear(&mut self) {
-        self.heap.clear();
-        self.h = 0;
+    #[inline]
+    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)
+            })
     }
 
-    pub fn to_list<Iter: Iterator<Item = Addr>>(&mut self, values: Iter) -> usize {
-        let head_addr = self.h;
+    #[inline]
+    fn write_pstr(&mut self, mut src: &str) -> Option<Addr> {
+        let orig_h = self.h();
 
-        for value in values {
-            let h = self.h;
+        loop {
+            if src == "" {
+                return if orig_h == self.h() {
+                    None
+                } else {
+                    let tail_h = self.h() - 1;
+                    self[tail_h] = HeapCellValue::Addr(Addr::HeapCell(tail_h));
 
+                    Some(Addr::PStrLocation(orig_h, 0))
+                };
+            }
+
+            let h = self.h();
+
+            let (pstr, rest_src) =
+                match PartialString::new(src) {
+                    Some(tuple) => {
+                        tuple
+                    }
+                    None => {
+                        if src.len() > '\u{0}'.len_utf8() {
+                            src = &src['\u{0}'.len_utf8() ..];
+                            continue;
+                        } else if orig_h == h {
+                            return None;
+                        } else {
+                            self[h - 1] = HeapCellValue::Addr(Addr::HeapCell(h - 1));
+                            return Some(Addr::PStrLocation(orig_h, 0));
+                        }
+                    }
+                };
+
+            self.push(HeapCellValue::PartialString(pstr, true));
+
+            if rest_src != "" {
+                self.push(HeapCellValue::Addr(Addr::PStrLocation(h + 2, 0)));
+                src = rest_src;
+            } else {
+                self.push(HeapCellValue::Addr(Addr::HeapCell(h + 1)));
+                return Some(Addr::PStrLocation(orig_h, 0));
+            }
+        }
+    }
+
+    #[inline]
+    pub(crate)
+    fn take(&mut self) -> Self {
+        HeapTemplate {
+            buf: self.buf.take(),
+            _marker: PhantomData,
+        }
+    }
+
+    #[inline]
+    pub(crate)
+    fn truncate(&mut self, h: usize) {
+        let new_top = h * mem::size_of::<HeapCellValue>() + self.buf.base as usize;
+        let mut h = new_top;
+
+        unsafe {
+            while h as *const _ < self.buf.top {
+                let val = h as *mut HeapCellValue;
+                ptr::drop_in_place(val);
+                h += mem::size_of::<HeapCellValue>();
+            }
+        }
+
+        self.buf.top = new_top as *const _;
+    }
+
+    #[inline]
+    pub(crate)
+    fn h(&self) -> usize {
+        (self.buf.top as usize - self.buf.base as usize) / mem::size_of::<HeapCellValue>()
+    }
+
+    pub(crate)
+    fn append(&mut self, vals: Vec<HeapCellValue>) {
+        for val in vals {
+            self.push(val);
+        }
+    }
+
+    pub(crate)
+    fn clear(&mut self) {
+        if !self.buf.base.is_null() {
+            self.truncate(0);
+            self.buf.top = self.buf.base;
+        }
+    }
+
+    pub(crate)
+    fn to_list<Iter, SrcT>(&mut self, values: Iter) -> usize
+        where Iter: Iterator<Item = SrcT>,
+              SrcT: Into<HeapCellValue>
+    {
+        let head_addr = self.h();
+        let mut h = head_addr;
+
+        for value in values.map(|v| v.into()) {
             self.push(HeapCellValue::Addr(Addr::Lis(h + 1)));
-            self.push(HeapCellValue::Addr(value));
+            self.push(value);
+
+            h += 2;
         }
 
-        self.push(HeapCellValue::Addr(Addr::Con(Constant::EmptyList)));
+        self.push(HeapCellValue::Addr(Addr::EmptyList));
+
         head_addr
     }
 
-    pub fn extend<Iter: Iterator<Item = HeapCellValue>>(&mut self, iter: Iter) {
+    /* Create an iterator starting from the passed offset. */
+    pub(crate)
+    fn iter_from<'a>(&'a self, offset: usize) -> HeapIter<'a, T> {
+        HeapIter::new(&self.buf, offset * mem::size_of::<HeapCellValue>())
+    }
+
+    pub(crate)
+    fn iter_mut_from<'a>(&'a mut self, offset: usize) -> HeapIterMut<'a, T> {
+        HeapIterMut::new(&mut self.buf, offset * mem::size_of::<HeapCellValue>())
+    }
+
+    pub(crate)
+    fn into_iter(mut self) -> HeapIntoIter<T> {
+        HeapIntoIter { buf: self.buf.take(), offset: 0 }
+    }
+
+    pub(crate)
+    fn extend<Iter: Iterator<Item = HeapCellValue>>(&mut self, iter: Iter) {
         for hcv in iter {
             self.push(hcv);
         }
     }
+
+    pub(crate)
+    fn to_local_code_ptr(&self, addr: &Addr) -> Option<LocalCodePtr> {
+        let extract_integer = |s: usize| -> Option<usize> {
+            match &self[s] {
+                &HeapCellValue::Addr(Addr::Fixnum(n)) => usize::try_from(n).ok(),
+                &HeapCellValue::Integer(ref n) => n.to_usize(),
+                _ => None
+            }
+        };
+
+        match addr {
+            Addr::Str(s) => {
+                match &self[*s] {
+                    HeapCellValue::NamedStr(arity, ref name, _) => {
+                        match (name.as_str(), *arity) {
+                            ("dir_entry", 1) => {
+                                extract_integer(s+1).map(LocalCodePtr::DirEntry)
+                            }
+                            ("in_situ_dir_entry", 1) => {
+                                extract_integer(s+1).map(LocalCodePtr::InSituDirEntry)
+                            }
+                            ("top_level", 2) => {
+                                if let Some(chunk_num) = extract_integer(s+1) {
+                                    if let Some(p) = extract_integer(s+2) {
+                                        return Some(LocalCodePtr::TopLevel(chunk_num, p));
+                                    }
+                                }
+
+                                None
+                            }
+                            ("user_goal_expansion", 1) => {
+                                extract_integer(s+1).map(LocalCodePtr::UserGoalExpansion)
+                            }
+                            ("user_term_expansion", 1) => {
+                                extract_integer(s+1).map(LocalCodePtr::UserTermExpansion)
+                            }
+                            _ => None
+                        }
+                    }
+                    _ => unreachable!()
+                }
+            }
+            _ => None
+        }
+    }
+
+    #[inline]
+    pub
+    fn index_addr<'a>(&'a self, addr: &Addr) -> RefOrOwned<'a, HeapCellValue> {
+        match addr {
+            &Addr::Con(h) | &Addr::Str(h) | &Addr::Stream(h) => {
+                RefOrOwned::Borrowed(&self[h])
+            }
+            addr => {
+                RefOrOwned::Owned(HeapCellValue::Addr(*addr))
+            }
+        }
+    }
 }
 
-impl Index<usize> for Heap {
+impl<T: RawBlockTraits> Index<usize> for HeapTemplate<T> {
     type Output = HeapCellValue;
 
+    #[inline]
     fn index(&self, index: usize) -> &Self::Output {
-        &self.heap[index]
+        unsafe {
+            let ptr = self.buf.base as usize + index * mem::size_of::<HeapCellValue>();
+            &*(ptr as *const HeapCellValue)
+        }
     }
 }
 
-impl IndexMut<usize> for Heap {
+impl<T: RawBlockTraits> IndexMut<usize> for HeapTemplate<T> {
+    #[inline]
     fn index_mut(&mut self, index: usize) -> &mut Self::Output {
-        &mut self.heap[index]
+        unsafe {
+            let ptr = self.buf.base as usize + index * mem::size_of::<HeapCellValue>();
+            &mut *(ptr as *mut HeapCellValue)
+        }
     }
 }

src/prolog/machine/machine_errors.rs

@@ -1,10 +1,13 @@
 use prolog_parser::ast::*;
-use prolog_parser::string_list::*;
 
+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 std::rc::Rc;
+
 pub(crate) type MachineStub = Vec<HeapCellValue>;
 
 #[derive(Clone, Copy)]
@@ -19,34 +22,103 @@ pub(super) struct MachineError {
     from: ErrorProvenance,
 }
 
-impl MachineError {
-    pub(super) fn functor_stub(name: ClauseName, arity: usize) -> MachineStub {
-        let name = HeapCellValue::Addr(Addr::Con(Constant::Atom(name, None)));
-        functor!(
-            "/",
-            2,
-            [name, heap_integer!(Integer::from(arity))],
-            SharedOpDesc::new(400, YFX)
-        )
-    }
+pub(super)
+trait TypeError {
+    fn type_error(self, h: usize, valid_type: ValidType) -> MachineError;
+}
+
+impl TypeError for Addr {
+    fn type_error(self, _: usize, valid_type: ValidType) -> MachineError {
+        let stub = functor!(
+            "type_error",
+            [atom(valid_type.as_str()), addr(self)]
+        );
 
-    pub(super) fn evaluation_error(eval_error: EvalError) -> Self {
-        let stub = functor!("evaluation_error", 1, [heap_atom!(eval_error.as_str())]);
         MachineError {
             stub,
             location: None,
-            from: ErrorProvenance::Received,
+            from: ErrorProvenance::Received
         }
     }
+}
 
-    pub(super) fn type_error(valid_type: ValidType, culprit: Addr) -> Self {
+impl TypeError for MachineStub {
+    fn type_error(self, h: usize, valid_type: ValidType) -> MachineError {
         let stub = functor!(
             "type_error",
-            2,
-            [
-                heap_atom!(valid_type.as_str()),
-                HeapCellValue::Addr(culprit)
-            ]
+            [atom(valid_type.as_str()), aux(h, 0)],
+            [self]
+        );
+
+        MachineError {
+            stub,
+            location: None,
+            from: ErrorProvenance::Constructed
+        }
+    }
+}
+
+impl TypeError for Number {
+    fn type_error(self, _h: usize, valid_type: ValidType) -> MachineError {
+        let stub = functor!(
+            "type_error",
+            [atom(valid_type.as_str()), number(self)]
+        );
+
+        MachineError {
+            stub,
+            location: None,
+            from: ErrorProvenance::Received
+        }
+    }
+}
+
+pub(super)
+trait PermissionError {
+    fn permission_error(self, h: usize, index_str: &'static str, perm: Permission) -> MachineError;
+}
+
+impl PermissionError for Addr {
+    fn permission_error(self, _: usize, index_str: &'static str, perm: Permission) -> MachineError {
+        let stub = functor!(
+            "permission_error",
+            [atom(perm.as_str()), atom(index_str), addr(self)]
+        );
+
+        MachineError {
+            stub,
+            location: None,
+            from: ErrorProvenance::Received
+        }
+    }
+}
+
+impl PermissionError for MachineStub {
+    fn permission_error(self, h: usize, index_str: &'static str, perm: Permission) -> MachineError {
+        let stub = functor!(
+            "permission_error",
+            [atom(perm.as_str()), atom(index_str), aux(h, 0)],
+            [self]
+        );
+
+        MachineError {
+            stub,
+            location: None,
+            from: ErrorProvenance::Constructed
+        }
+    }
+}
+
+pub(super)
+trait DomainError {
+    fn domain_error(self, error: DomainErrorType) -> MachineError;
+}
+
+impl DomainError for Addr {
+    fn domain_error(self, error: DomainErrorType) -> MachineError {
+        let stub = functor!(
+            "domain_error",
+            [atom(error.as_str()), addr(self)]
         );
 
         MachineError {
@@ -55,37 +127,74 @@ impl MachineError {
             from: ErrorProvenance::Received,
         }
     }
+}
 
-    pub(super) fn module_resolution_error(
+impl DomainError for Number {
+    fn domain_error(self, error: DomainErrorType) -> MachineError {
+        let stub = functor!(
+            "domain_error",
+            [atom(error.as_str()), number(self)]
+        );
+
+        MachineError {
+            stub,
+            location: None,
+            from: ErrorProvenance::Received,
+        }
+    }
+}
+
+impl MachineError {
+    pub(super)
+    fn functor_stub(name: ClauseName, arity: usize) -> MachineStub {
+        functor!(
+            "/",
+            SharedOpDesc::new(400, YFX),
+            [clause_name(name), integer(arity)]
+        )
+    }
+
+    pub(super)
+    fn evaluation_error(eval_error: EvalError) -> Self {
+        let stub = functor!("evaluation_error", [atom(eval_error.as_str())]);
+
+        MachineError {
+            stub,
+            location: None,
+            from: ErrorProvenance::Received,
+        }
+    }
+
+    pub(super)
+    fn type_error<T: TypeError>(h: usize, valid_type: ValidType, culprit: T) -> Self {
+        culprit.type_error(h, valid_type)
+    }
+
+    pub(super)
+    fn module_resolution_error(
         h: usize,
         mod_name: ClauseName,
         name: ClauseName,
         arity: usize,
     ) -> Self {
-        let mod_name = HeapCellValue::Addr(Addr::Con(Constant::Atom(mod_name, None)));
-        let name = HeapCellValue::Addr(Addr::Con(Constant::Atom(name, None)));
-
-        let mut stub = functor!(
-            "evaluation_error",
-            1,
-            [HeapCellValue::Addr(Addr::HeapCell(h + 2))]
+        let res_stub = functor!(
+            ":",
+            SharedOpDesc::new(600, XFY),
+            [clause_name(mod_name), clause_name(name)]
         );
 
-        stub.append(&mut functor!(
+        let ind_stub = functor!(
             "/",
-            2,
-            [
-                HeapCellValue::Addr(Addr::HeapCell(h + 2 + 3)),
-                heap_integer!(Integer::from(arity))
-            ],
-            SharedOpDesc::new(400, YFX)
-        ));
-        stub.append(&mut functor!(
-            ":",
-            2,
-            [mod_name, name],
-            SharedOpDesc::new(600, XFY)
-        ));
+            SharedOpDesc::new(400, YFX),
+            [aux(h + 2, 0), integer(arity)],
+            [res_stub]
+        );
+
+        let stub = functor!(
+            "evaluation_error",
+            [aux(h, 0)],
+            [ind_stub]
+        );
 
         MachineError {
             stub,
@@ -94,25 +203,33 @@ impl MachineError {
         }
     }
 
-    pub(super) fn existence_error(h: usize, err: ExistenceError) -> Self {
+    pub(super)
+    fn existence_error(h: usize, err: ExistenceError) -> Self {
         match err {
-            ExistenceError::Procedure(name, arity) => {
-                let mut stub = functor!(
-                    "existence_error",
-                    2,
-                    [heap_atom!("procedure"), heap_str!(3 + h)]
-                );
-                stub.append(&mut Self::functor_stub(name, arity));
-
-                MachineError {
-                    stub,
-                    location: None,
-                    from: ErrorProvenance::Constructed,
-                }
-            }
             ExistenceError::Module(name) => {
-                let name = HeapCellValue::Addr(Addr::Con(Constant::Atom(name, None)));
-                let stub = functor!("existence_error", 2, [heap_atom!("module"), name]);
+                let stub = functor!(
+                    "existence_error",
+                    [atom("source_sink"), clause_name(name)]
+                );
+
+                MachineError {
+                    stub,
+                    location: None,
+                    from: ErrorProvenance::Received,
+                }
+            }
+            ExistenceError::Procedure(name, arity) => {
+                let culprit = functor!(
+                    "/",
+                    SharedOpDesc::new(400, YFX),
+                    [clause_name(name), integer(arity)]
+                );
+
+                let stub = functor!(
+                    "existence_error",
+                    [atom("procedure"), aux(h, 0)],
+                    [culprit]
+                );
 
                 MachineError {
                     stub,
@@ -120,97 +237,168 @@ impl MachineError {
                     from: ErrorProvenance::Constructed,
                 }
             }
+            ExistenceError::SourceSink(source) => {
+                let source_stub = source.as_functor_stub();
+
+                let stub = functor!(
+                    "existence_error",
+                    [atom("source_sink"), aux(h, 0)],
+                    [source_stub]
+                );
+
+                MachineError {
+                    stub,
+                    location: None,
+                    from: ErrorProvenance::Constructed,
+                }
+            }
+            ExistenceError::Stream(culprit) => {
+                let stub = functor!(
+                    "existence_error",
+                    [atom("stream"), addr(culprit)]
+                );
+
+                MachineError {
+                    stub,
+                    location: None,
+                    from: ErrorProvenance::Received,
+                }
+            }
         }
     }
 
-    pub(super) fn session_error(h: usize, err: SessionError) -> Self {
-        match err {
-            SessionError::ParserError(err) => Self::syntax_error(h, err),
-            SessionError::CannotOverwriteBuiltIn(pred_str)
-          | SessionError::CannotOverwriteImport(pred_str) => {
-                Self::permission_error(PermissionError::Modify, "private_procedure", pred_str)
-            }
-            SessionError::InvalidFileName(filename) => {
-                Self::existence_error(h, ExistenceError::Module(filename))
-            }
-            SessionError::ModuleDoesNotContainExport => Self::permission_error(
-                PermissionError::Access,
-                "private_procedure",
-                clause_name!("module_does_not_contain_claimed_export"),
-            ),
-            SessionError::ModuleNotFound => Self::permission_error(
-                PermissionError::Access,
-                "private_procedure",
-                clause_name!("module_does_not_exist"),
-            ),
-            SessionError::NoModuleDeclaration(name) => {
-                Self::existence_error(h, ExistenceError::Module(name))
-            }
-            SessionError::OpIsInfixAndPostFix(op) => {
-                Self::permission_error(PermissionError::Create, "operator", op)
-            }
-            _ => unreachable!(),
-        }
-    }
-
-    pub(super) fn permission_error(
-        err: PermissionError,
+    pub(super)
+    fn permission_error<T: PermissionError>(
+        h: usize,
+        err: Permission,
         index_str: &'static str,
-        pred_str: ClauseName,
+        culprit: T,
     ) -> Self {
-        let pred_str = HeapCellValue::Addr(Addr::Con(Constant::Atom(pred_str, None)));
-
-        let err = vec![heap_atom!(err.as_str()), heap_atom!(index_str), pred_str];
-        let mut stub = functor!("permission_error", 3);
-
-        stub.extend(err.into_iter());
-
-        MachineError {
-            stub,
-            location: None,
-            from: ErrorProvenance::Constructed,
-        }
+        culprit.permission_error(
+            h,
+            index_str,
+            err,
+        )
     }
 
     fn arithmetic_error(h: usize, err: ArithmeticError) -> Self {
         match err {
-            ArithmeticError::UninstantiatedVar => Self::instantiation_error(),
+            ArithmeticError::UninstantiatedVar => {
+                Self::instantiation_error()
+            }
             ArithmeticError::NonEvaluableFunctor(name, arity) => {
-                let name = HeapCellValue::Addr(Addr::Con(name));
                 let culprit = functor!(
                     "/",
-                    2,
-                    [name, heap_integer!(Integer::from(arity))],
-                    SharedOpDesc::new(400, YFX)
+                    SharedOpDesc::new(400, YFX),
+                    [constant(h, &name), integer(arity)]
                 );
 
-                let mut stub = Self::type_error(ValidType::Evaluable, Addr::HeapCell(3 + h)).stub;
-                stub.extend(culprit.into_iter());
-
-                MachineError {
-                    stub,
-                    location: None,
-                    from: ErrorProvenance::Constructed,
-                }
+                Self::type_error(h, ValidType::Evaluable, culprit)
             }
         }
     }
 
-    pub(super) fn syntax_error(h: usize, err: ParserError) -> Self {
+    #[inline]
+    pub(super)
+    fn domain_error<T: DomainError>(error: DomainErrorType, culprit: T) -> Self {
+        culprit.domain_error(error)
+    }
+
+    pub(super)
+    fn instantiation_error() -> Self {
+        let stub = functor!("instantiation_error");
+
+        MachineError {
+            stub,
+            location: None,
+            from: ErrorProvenance::Received,
+        }
+    }
+
+    pub(super)
+    fn uninstantiation_error(culprit: Addr) -> Self {
+        let stub = functor!(
+            "uninstantiation_error",
+            [addr(culprit)]
+        );
+
+        MachineError {
+            stub,
+            location: None,
+            from: ErrorProvenance::Received,
+        }
+    }
+
+    pub(super)
+    fn session_error(h: usize, err: SessionError) -> Self {
+        match err {
+            SessionError::CannotOverwriteBuiltIn(pred_str) |
+            SessionError::CannotOverwriteImport(pred_str) => {
+                Self::permission_error(
+                    h,
+                    Permission::Modify,
+                    "private_procedure",
+                    functor!(clause_name(pred_str)),
+                )
+            }
+            SessionError::ExistenceError(err) => {
+                Self::existence_error(h, err)
+            }
+            SessionError::InvalidFileName(filename) => {
+                Self::existence_error(h, ExistenceError::Module(filename))
+            }
+            SessionError::ModuleDoesNotContainExport(..) => {
+                Self::permission_error(
+                    h,
+                    Permission::Access,
+                    "private_procedure",
+                    functor!("module_does_not_contain_claimed_export"),
+                )
+            }
+            SessionError::NamelessEntry => {
+                Self::permission_error(
+                    h,
+                    Permission::Create,
+                    "static_procedure",
+                    functor!("nameless_procedure")
+                )
+            }
+            SessionError::OpIsInfixAndPostFix(op) => {
+                Self::permission_error(
+                    h,
+                    Permission::Create,
+                    "operator",
+                    functor!(clause_name(op)),
+                )
+            }
+            SessionError::ParserError(err) => {
+                Self::syntax_error(h, err)
+            }
+            SessionError::QueryCannotBeDefinedAsFact => {
+                Self::permission_error(
+                    h,
+                    Permission::Create,
+                    "static_procedure",
+                    functor!("query_cannot_be_defined_as_fact")
+                )
+            }
+        }
+    }
+
+    pub(super)
+    fn syntax_error(h: usize, err: ParserError) -> Self {
         if let ParserError::Arithmetic(err) = err {
             return Self::arithmetic_error(h, err);
         }
 
         let location = err.line_and_col_num();
-        let err = vec![heap_atom!(err.as_str())];
+        let stub = functor!(err.as_str());
 
-        let mut stub = if err.len() == 1 {
-            functor!("syntax_error", 1)
-        } else {
-            functor!("syntax_error", 1, [heap_str!(h + 2)])
-        };
-
-        stub.extend(err.into_iter());
+        let stub = functor!(
+            "syntax_error",
+            [aux(h, 0)],
+            [stub]
+        );
 
         MachineError {
             stub,
@@ -219,30 +407,10 @@ impl MachineError {
         }
     }
 
-    pub(super) fn domain_error(error: DomainError, culprit: Addr) -> Self {
-        let stub = functor!(
-            "domain_error",
-            2,
-            [heap_atom!(error.as_str()), HeapCellValue::Addr(culprit)]
-        );
-        MachineError {
-            stub,
-            location: None,
-            from: ErrorProvenance::Received,
-        }
-    }
+    pub(super)
+    fn representation_error(flag: RepFlag) -> Self {
+        let stub = functor!("representation_error", [atom(flag.as_str())]);
 
-    pub(super) fn instantiation_error() -> Self {
-        let stub = functor!("instantiation_error");
-        MachineError {
-            stub,
-            location: None,
-            from: ErrorProvenance::Received,
-        }
-    }
-
-    pub(super) fn representation_error(flag: RepFlag) -> Self {
-        let stub = functor!("representation_error", 1, [heap_atom!(flag.as_str())]);
         MachineError {
             stub,
             location: None,
@@ -268,18 +436,22 @@ impl MachineError {
 }
 
 #[derive(Clone, Copy)]
-pub enum PermissionError {
+pub enum Permission {
     Access,
     Create,
+    InputStream,
     Modify,
+    OutputStream,
 }
 
-impl PermissionError {
+impl Permission {
     pub fn as_str(self) -> &'static str {
         match self {
-            PermissionError::Access => "access",
-            PermissionError::Create => "create",
-            PermissionError::Modify => "modify",
+            Permission::Access => "access",
+            Permission::Create => "create",
+            Permission::InputStream => "input",
+            Permission::Modify => "modify",
+            Permission::OutputStream => "output",
         }
     }
 }
@@ -331,14 +503,18 @@ impl ValidType {
 }
 
 #[derive(Clone, Copy)]
-pub enum DomainError {
+pub enum DomainErrorType {
     NotLessThanZero,
+    Stream,
+    StreamOrAlias,
 }
 
-impl DomainError {
+impl DomainErrorType {
     pub fn as_str(self) -> &'static str {
         match self {
-            DomainError::NotLessThanZero => "not_less_than_zero",
+            DomainErrorType::NotLessThanZero => "not_less_than_zero",
+            DomainErrorType::Stream => "stream",
+            DomainErrorType::StreamOrAlias => "stream_or_alias",
         }
     }
 }
@@ -388,18 +564,20 @@ impl EvalError {
 }
 
 // used by '$skip_max_list'.
+#[derive(Clone, Copy)]
 pub(super) enum CycleSearchResult {
     EmptyList,
     NotList,
-    PartialList(usize, usize), // the list length (up to max), and an offset into the heap.
-    ProperList(usize),         // the list length.
-    String(usize, StringList), // the number of elements iterated, the string tail.
-    UntouchedList(usize),      // the address of an uniterated Addr::Lis(address).
+    PartialList(usize, Ref),           // the list length (up to max), and an offset into the heap.
+    ProperList(usize),                 // the list length.
+    PStrLocation(usize, usize, usize), // the list length (up to max), the heap offset, byte offset into the string.
+    UntouchedList(usize),              // the address of an uniterated Addr::Lis(address).
 }
 
 impl MachineState {
     // see 8.4.3 of Draft Technical Corrigendum 2.
-    pub(super) fn check_sort_errors(&self) -> CallResult {
+    pub(super)
+    fn check_sort_errors(&self) -> CallResult {
         let stub = MachineError::functor_stub(clause_name!("sort"), 2);
         let list = self.store(self.deref(self[temp_v!(1)].clone()));
         let sorted = self.store(self.deref(self[temp_v!(2)].clone()));
@@ -409,14 +587,14 @@ impl MachineState {
                 return Err(self.error_form(MachineError::instantiation_error(), stub))
             }
             CycleSearchResult::NotList => {
-                return Err(self.error_form(MachineError::type_error(ValidType::List, list), stub))
+                return Err(self.error_form(MachineError::type_error(0, ValidType::List, list), stub))
             }
             _ => {}
         };
 
         match self.detect_cycles(sorted.clone()) {
             CycleSearchResult::NotList if !sorted.is_ref() => {
-                Err(self.error_form(MachineError::type_error(ValidType::List, sorted), stub))
+                Err(self.error_form(MachineError::type_error(0, ValidType::List, sorted), stub))
             }
             _ => Ok(()),
         }
@@ -427,7 +605,7 @@ impl MachineState {
 
         match self.detect_cycles(list.clone()) {
             CycleSearchResult::NotList if !list.is_ref() => {
-                Err(self.error_form(MachineError::type_error(ValidType::List, list), stub))
+                Err(self.error_form(MachineError::type_error(0, ValidType::List, list), stub))
             }
             _ => {
                 let mut addr = list;
@@ -436,18 +614,23 @@ impl MachineState {
                     let mut new_l = l;
 
                     loop {
-                        match self.heap[new_l].clone() {
-                            HeapCellValue::Addr(Addr::Str(l)) => new_l = l,
-                            HeapCellValue::NamedStr(2, ref name, Some(_))
-                                if name.as_str() == "-" =>
-                            {
-                                break
+                        match self.heap.clone(new_l) {
+                            HeapCellValue::Addr(Addr::Str(l)) => {
+                                new_l = l;
+                            }
+                            HeapCellValue::NamedStr(2, ref name, Some(_))
+                                if name.as_str() == "-" => {
+                                break;
+                            }
+                            HeapCellValue::Addr(Addr::HeapCell(_)) => {
+                                break;
+                            }
+                            HeapCellValue::Addr(Addr::StackCell(..)) => {
+                                break;
                             }
-                            HeapCellValue::Addr(Addr::HeapCell(_)) => break,
-                            HeapCellValue::Addr(Addr::StackCell(..)) => break,
                             _ => {
                                 return Err(self.error_form(
-                                    MachineError::type_error(ValidType::Pair, Addr::HeapCell(l)),
+                                    MachineError::type_error(0, ValidType::Pair, Addr::HeapCell(l)),
                                     stub,
                                 ))
                             }
@@ -463,9 +646,11 @@ impl MachineState {
     }
 
     // see 8.4.4 of Draft Technical Corrigendum 2.
-    pub(super) fn check_keysort_errors(&self) -> CallResult {
+    pub(super)
+    fn check_keysort_errors(&self) -> CallResult {
         let stub = MachineError::functor_stub(clause_name!("keysort"), 2);
-        let pairs = self.store(self.deref(self[temp_v!(1)].clone()));
+
+        let pairs  = self.store(self.deref(self[temp_v!(1)].clone()));
         let sorted = self.store(self.deref(self[temp_v!(2)].clone()));
 
         match self.detect_cycles(pairs.clone()) {
@@ -473,7 +658,7 @@ impl MachineState {
                 Err(self.error_form(MachineError::instantiation_error(), stub))
             }
             CycleSearchResult::NotList => {
-                Err(self.error_form(MachineError::type_error(ValidType::List, pairs), stub))
+                Err(self.error_form(MachineError::type_error(0, ValidType::List, pairs), stub))
             }
             _ => Ok(()),
         }?;
@@ -481,11 +666,12 @@ impl MachineState {
         self.check_for_list_pairs(sorted)
     }
 
-    pub(super) fn error_form(&self, err: MachineError, src: MachineStub) -> MachineStub {
+    pub(super)
+    fn error_form(&self, err: MachineError, src: MachineStub) -> MachineStub {
         let location = err.location;
         let err_len = err.len();
 
-        let h = self.heap.h;
+        let h = self.heap.h();
         let mut stub = vec![
             HeapCellValue::NamedStr(2, clause_name!("error"), None),
             HeapCellValue::Addr(Addr::HeapCell(h + 3)),
@@ -497,22 +683,18 @@ impl MachineState {
         if let Some((line_num, _)) = location {
             let colon_op_desc = Some(SharedOpDesc::new(600, XFY));
 
-            stub.extend(
-                vec![
-                    HeapCellValue::NamedStr(2, clause_name!(":"), colon_op_desc),
-                    HeapCellValue::Addr(Addr::HeapCell(h + 6 + err_len)),
-                    heap_integer!(Integer::from(line_num)),
-                ]
-                .into_iter(),
-            );
+            stub.push(HeapCellValue::NamedStr(2, clause_name!(":"), colon_op_desc));
+            stub.push(HeapCellValue::Addr(Addr::HeapCell(h + 6 + err_len)));
+            stub.push(HeapCellValue::Integer(Rc::new(Integer::from(line_num))));
         }
 
         stub.extend(src.into_iter());
         stub
     }
 
-    pub(super) fn throw_exception(&mut self, err: MachineStub) {
-        let h = self.heap.h;
+    pub(super)
+    fn throw_exception(&mut self, err: MachineStub) {
+        let h = self.heap.h();
 
         self.ball.boundary = 0;
         self.ball.stub.truncate(0);
@@ -529,27 +711,25 @@ impl MachineState {
 pub enum ExistenceError {
     Module(ClauseName),
     Procedure(ClauseName, usize),
+    SourceSink(ModuleSource),
+    Stream(Addr),
 }
 
 pub enum SessionError {
     CannotOverwriteBuiltIn(ClauseName),
     CannotOverwriteImport(ClauseName),
+    ExistenceError(ExistenceError),
     InvalidFileName(ClauseName),
-    ModuleDoesNotContainExport,
-    ModuleNotFound,
+    ModuleDoesNotContainExport(ClauseName, PredicateKey),
     NamelessEntry,
-    NoModuleDeclaration(ClauseName),
     OpIsInfixAndPostFix(ClauseName),
+    QueryCannotBeDefinedAsFact,
     ParserError(ParserError),
-    UserPrompt,
 }
 
 pub enum EvalSession {
     EntrySuccess,
     Error(SessionError),
-    InitialQuerySuccess(AllocVarDict),
-    QueryFailure,
-    SubsequentQuerySuccess,
 }
 
 impl From<SessionError> for EvalSession {
@@ -568,4 +748,5 @@ impl From<ParserError> for EvalSession {
     fn from(err: ParserError) -> Self {
         EvalSession::from(SessionError::ParserError(err))
     }
+
 }

src/prolog/machine/machine_indices.rs

@@ -4,13 +4,23 @@ use 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 indexmap::IndexMap;
 
 use std::cell::RefCell;
 use std::cmp::Ordering;
 use std::collections::{BTreeMap, VecDeque};
+use std::convert::TryFrom;
 use std::mem;
 use std::ops::{Add, AddAssign, Sub, SubAssign};
 use std::rc::Rc;
@@ -32,18 +42,36 @@ pub enum DBRef {
     ),
 }
 
-#[derive(Clone, PartialEq, Eq, Hash)]
-pub enum Addr {
-    AttrVar(usize),
-    Con(Constant),
-    DBRef(DBRef),
-    Lis(usize),
-    HeapCell(usize),
-    StackCell(usize, usize),
-    Str(usize),
+// 7.2
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum TermOrderCategory {
+    Variable,
+    FloatingPoint,
+    Integer,
+    Atom,
+    Compound,
 }
 
-#[derive(Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Addr {
+    AttrVar(usize),
+    Char(char),
+    CharCode(u32),
+    Con(usize),
+    CutPoint(usize),
+    EmptyList,
+    Fixnum(isize),
+    Float(OrderedFloat<f64>),
+    Lis(usize),
+    HeapCell(usize),
+    PStrLocation(usize, usize), // location of pstr in heap, offset into string in bytes.
+    StackCell(usize, usize),
+    Str(usize),
+    Stream(usize),
+    Usize(usize),
+}
+
+#[derive(Clone, Copy, Hash, Eq, PartialEq, PartialOrd)]
 pub enum Ref {
     AttrVar(usize),
     HeapCell(usize),
@@ -60,6 +88,28 @@ impl Ref {
     }
 }
 
+impl Ord for Ref {
+    fn cmp(&self, other: &Ref) -> Ordering {
+        match (self, other) {
+            (Ref::AttrVar(h1), Ref::AttrVar(h2))
+          | (Ref::HeapCell(h1), Ref::HeapCell(h2))
+          | (Ref::HeapCell(h1), Ref::AttrVar(h2))
+          | (Ref::AttrVar(h1), Ref::HeapCell(h2)) => {
+                h1.cmp(&h2)
+            }
+            (Ref::StackCell(fr1, sc1), Ref::StackCell(fr2, sc2)) => {
+                fr1.cmp(&fr2).then_with(|| sc1.cmp(&sc2))
+            }
+            (Ref::StackCell(..), _) => {
+                Ordering::Greater
+            }
+            (_, Ref::StackCell(..)) => {
+                Ordering::Less
+            }
+        }
+    }
+}
+
 impl PartialEq<Ref> for Addr {
     fn eq(&self, r: &Ref) -> bool {
         self.as_var() == Some(*r)
@@ -70,35 +120,67 @@ impl PartialEq<Ref> for Addr {
 impl PartialOrd<Ref> for Addr {
     fn partial_cmp(&self, r: &Ref) -> Option<Ordering> {
         match self {
-            &Addr::StackCell(fr, sc) => match *r {
-                Ref::AttrVar(_) | Ref::HeapCell(_) => Some(Ordering::Greater),
-                Ref::StackCell(fr1, sc1) => {
-                    if fr1 < fr || (fr1 == fr && sc1 < sc) {
+            &Addr::StackCell(fr, sc) => {
+                match *r {
+                    Ref::AttrVar(_) | Ref::HeapCell(_) => {
                         Some(Ordering::Greater)
-                    } else if fr1 == fr && sc1 == sc {
-                        Some(Ordering::Equal)
-                    } else {
-                        Some(Ordering::Less)
+                    }
+                    Ref::StackCell(fr1, sc1) => {
+                        if fr1 < fr || (fr1 == fr && sc1 < sc) {
+                            Some(Ordering::Greater)
+                        } else if fr1 == fr && sc1 == sc {
+                            Some(Ordering::Equal)
+                        } else {
+                            Some(Ordering::Less)
+                        }
                     }
                 }
-            },
-            &Addr::HeapCell(h) | &Addr::AttrVar(h) => match r {
-                &Ref::StackCell(..) => Some(Ordering::Less),
-                &Ref::AttrVar(h1) | &Ref::HeapCell(h1) => h.partial_cmp(&h1),
-            },
-            _ => None,
+            }
+            &Addr::HeapCell(h) | &Addr::AttrVar(h) => {
+                match r {
+                    Ref::StackCell(..) => {
+                        Some(Ordering::Less)
+                    }
+                    Ref::AttrVar(h1) | Ref::HeapCell(h1) => {
+                        h.partial_cmp(h1)
+                    }
+                }
+            }
+            _ => {
+                None
+            }
         }
     }
 }
 
 impl Addr {
-    pub fn is_ref(&self) -> bool {
+    #[inline]
+    pub fn is_heap_bound(&self) -> bool {
         match self {
-            &Addr::AttrVar(_) | &Addr::HeapCell(_) | &Addr::StackCell(_, _) => true,
-            _ => false,
+            Addr::Char(_) | Addr::CharCode(_) | Addr::EmptyList |
+            Addr::CutPoint(_) | Addr::Usize(_) | Addr::Fixnum(_) |
+            Addr::Float(_) => {
+                false
+            }
+            _ => {
+                true
+            }
         }
     }
 
+    #[inline]
+    pub fn is_ref(&self) -> bool {
+        match self {
+            Addr::HeapCell(_) | Addr::StackCell(_, _) | Addr::AttrVar(_) => {
+                true
+            }
+            _ => {
+                false
+            }
+        }
+    }
+
+    #[inline]
     pub fn as_var(&self) -> Option<Ref> {
         match self {
             &Addr::AttrVar(h) => Some(Ref::AttrVar(h)),
@@ -108,6 +190,105 @@ impl Addr {
         }
     }
 
+    pub(super)
+    fn order_category(&self, heap: &Heap) -> Option<TermOrderCategory> {
+        match Number::try_from((*self, heap)) {
+            Ok(Number::Integer(_)) | Ok(Number::Fixnum(_)) | Ok(Number::Rational(_)) => {
+                Some(TermOrderCategory::Integer)
+            }
+            Ok(Number::Float(_)) => {
+                Some(TermOrderCategory::FloatingPoint)
+            }
+            _ => {
+                match self {
+                    Addr::HeapCell(_) | Addr::AttrVar(_) | Addr::StackCell(..) => {
+                        Some(TermOrderCategory::Variable)
+                    }
+                    Addr::Float(_) => {
+                        Some(TermOrderCategory::FloatingPoint)
+                    }
+                    &Addr::Con(h) => {
+                        match &heap[h] {
+                            HeapCellValue::Atom(..) => {
+                                Some(TermOrderCategory::Atom)
+                            }
+                            HeapCellValue::DBRef(_) => {
+                                None
+                            }
+                            _ => {
+                                unreachable!()
+                            }
+                        }
+                    }
+                    Addr::Char(_) | Addr::EmptyList => {
+                        Some(TermOrderCategory::Atom)
+                    }
+                    Addr::CharCode(_) | Addr::Fixnum(_) | Addr::Usize(_) => {
+                        Some(TermOrderCategory::Integer)
+                    }
+                    Addr::Lis(_) | Addr::PStrLocation(..) | Addr::Str(_) => {
+                        Some(TermOrderCategory::Compound)
+                    }
+                    Addr::CutPoint(_) | Addr::Stream(_) => {
+                        None
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn as_constant(&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::Integer(ref n) => {
+                        Some(Constant::Integer(n.clone()))
+                    }
+                    &HeapCellValue::Rational(ref n) => {
+                        Some(Constant::Rational(n.clone()))
+                    }
+                    _ => {
+                        None
+                    }
+                }
+            }
+            &Addr::EmptyList => {
+                Some(Constant::EmptyList)
+            }
+            &Addr::Fixnum(n) => {
+                Some(Constant::Fixnum(n))
+            }
+            &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
+                }
+            }
+            _ => {
+                None
+            }
+        }
+    }
+
     pub fn is_protected(&self, e: usize) -> bool {
         match self {
             &Addr::StackCell(addr, _) if addr >= e => false,
@@ -121,10 +302,13 @@ impl Add<usize> for Addr {
 
     fn add(self, rhs: usize) -> Self::Output {
         match self {
+            Addr::Stream(h) => Addr::Stream(h + rhs),
+            Addr::Con(h) => Addr::Con(h + rhs),
             Addr::Lis(a) => Addr::Lis(a + rhs),
             Addr::AttrVar(h) => Addr::AttrVar(h + rhs),
             Addr::HeapCell(h) => Addr::HeapCell(h + rhs),
             Addr::Str(s) => Addr::Str(s + rhs),
+            Addr::PStrLocation(h, n) => Addr::PStrLocation(h + rhs, n),
             _ => self,
         }
     }
@@ -136,10 +320,13 @@ impl Sub<i64> for Addr {
     fn sub(self, rhs: i64) -> Self::Output {
         if rhs < 0 {
             match self {
+                Addr::Stream(h) => Addr::Stream(h + rhs.abs() as usize),
+                Addr::Con(h) => Addr::Con(h + rhs.abs() as usize),
                 Addr::Lis(a) => Addr::Lis(a + rhs.abs() as usize),
                 Addr::AttrVar(h) => Addr::AttrVar(h + rhs.abs() as usize),
                 Addr::HeapCell(h) => Addr::HeapCell(h + rhs.abs() as usize),
                 Addr::Str(s) => Addr::Str(s + rhs.abs() as usize),
+                Addr::PStrLocation(h, n) => Addr::PStrLocation(h + rhs.abs() as usize, n),
                 _ => self,
             }
         } else {
@@ -153,10 +340,13 @@ impl Sub<usize> for Addr {
 
     fn sub(self, rhs: usize) -> Self::Output {
         match self {
+            Addr::Stream(h) => Addr::Stream(h - rhs),
+            Addr::Con(h) => Addr::Con(h - rhs),
             Addr::Lis(a) => Addr::Lis(a - rhs),
             Addr::AttrVar(h) => Addr::AttrVar(h - rhs),
             Addr::HeapCell(h) => Addr::HeapCell(h - rhs),
             Addr::Str(s) => Addr::Str(s - rhs),
+            Addr::PStrLocation(h, n) => Addr::PStrLocation(h - rhs, n),
             _ => self,
         }
     }
@@ -168,20 +358,11 @@ impl SubAssign<usize> for Addr {
     }
 }
 
-impl From<Ref> for Addr {
-    fn from(r: Ref) -> Self {
-        match r {
-            Ref::AttrVar(h) => Addr::AttrVar(h),
-            Ref::HeapCell(h) => Addr::HeapCell(h),
-            Ref::StackCell(fr, sc) => Addr::StackCell(fr, sc),
-        }
-    }
-}
-
-#[derive(Clone)]
+#[derive(Clone, Copy)]
 pub enum TrailRef {
     Ref(Ref),
-    AttrVarLink(usize, Addr),
+    AttrVarHeapLink(usize),
+    AttrVarListLink(usize, usize),
 }
 
 impl From<Ref> for TrailRef {
@@ -190,32 +371,97 @@ impl From<Ref> for TrailRef {
     }
 }
 
-#[derive(Clone, PartialEq)]
 pub enum HeapCellValue {
     Addr(Addr),
+    Atom(ClauseName, Option<SharedOpDesc>),
+    DBRef(DBRef),
+    Integer(Rc<Integer>),
     NamedStr(usize, ClauseName, Option<SharedOpDesc>), // arity, name, precedence/Specifier if it has one.
+    Rational(Rc<Rational>),
+    PartialString(PartialString, bool), // the partial string, a bool indicating whether it came from a Constant.
+    Stream(Stream),
 }
 
 impl HeapCellValue {
+    #[inline]
     pub fn as_addr(&self, focus: usize) -> Addr {
         match self {
-            &HeapCellValue::Addr(ref a) => a.clone(),
-            &HeapCellValue::NamedStr(_, _, _) => Addr::Str(focus),
+            HeapCellValue::Addr(ref a) => {
+                *a
+            }
+            HeapCellValue::Atom(..) | HeapCellValue::DBRef(..) | HeapCellValue::Integer(..) |
+            HeapCellValue::Rational(..) => {
+                Addr::Con(focus)
+            }
+            HeapCellValue::NamedStr(_, _, _) => {
+                Addr::Str(focus)
+            }
+            HeapCellValue::PartialString(..) => {
+                Addr::PStrLocation(focus, 0)
+            }
+            HeapCellValue::Stream(_) => {
+                Addr::Stream(focus)
+            }
         }
     }
+
+    #[inline]
+    pub fn context_free_clone(&self) -> HeapCellValue {
+        match self {
+            &HeapCellValue::Addr(addr) => {
+                HeapCellValue::Addr(addr)
+            }
+            &HeapCellValue::Atom(ref name, ref op) => {
+                HeapCellValue::Atom(name.clone(), op.clone())
+            }
+            &HeapCellValue::DBRef(ref db_ref) => {
+                HeapCellValue::DBRef(db_ref.clone())
+            }
+            &HeapCellValue::Integer(ref n) => {
+                HeapCellValue::Integer(n.clone())
+            }
+            &HeapCellValue::NamedStr(arity, ref name, ref op) => {
+                HeapCellValue::NamedStr(arity, name.clone(), op.clone())
+            }
+            &HeapCellValue::Rational(ref r) => {
+                HeapCellValue::Rational(r.clone())
+            }
+            &HeapCellValue::PartialString(ref pstr, has_tail) => {
+                HeapCellValue::PartialString(pstr.clone(), has_tail)
+            }
+            &HeapCellValue::Stream(_) => {
+                HeapCellValue::Stream(Stream::null_stream())
+            }
+        }
+    }
+}
+
+impl From<Addr> for HeapCellValue {
+    #[inline]
+    fn from(value: Addr) -> HeapCellValue {
+        HeapCellValue::Addr(value)
+    }
 }
 
 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
 pub enum IndexPtr {
     DynamicUndefined, // a predicate, declared as dynamic, whose location in code is as yet undefined.
     Undefined,
+    InSituDirEntry(usize),
     Index(usize),
+    UserGoalExpansion,
+    UserTermExpansion
 }
 
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq)]
 pub struct CodeIndex(pub Rc<RefCell<(IndexPtr, ClauseName)>>);
 
 impl CodeIndex {
+    #[inline]
+    pub fn new(ptr: IndexPtr, module_name: ClauseName) -> Self {
+        CodeIndex(Rc::new(RefCell::new(( ptr, module_name ))))
+    }
+
     #[inline]
     pub fn is_undefined(&self) -> bool {
         let index_ptr = &self.0.borrow().0;
@@ -233,7 +479,7 @@ impl CodeIndex {
             module_name
         ))))
     }
-    
+
     #[inline]
     pub fn module_name(&self) -> ClauseName {
         self.0.borrow().1.clone()
@@ -299,7 +545,6 @@ pub enum DynamicTransactionType {
 #[derive(Clone, Copy, PartialOrd, Ord, PartialEq, Eq)]
 pub enum REPLCodePtr {
     CompileBatch,
-    SubmitQueryAndPrintResults,
     UseModule,
     UseQualifiedModule,
     UseModuleFromFile,
@@ -309,7 +554,7 @@ pub enum REPLCodePtr {
 #[derive(Clone, PartialEq)]
 pub enum CodePtr {
     BuiltInClause(BuiltInClauseType, LocalCodePtr), // local is the successor call.
-    CallN(usize, LocalCodePtr),                     // arity, local.
+    CallN(usize, LocalCodePtr, bool),               // arity, local, last call.
     Local(LocalCodePtr),
     DynamicTransaction(DynamicTransactionType, LocalCodePtr), // the type of transaction, the return pointer.
     REPL(REPLCodePtr, LocalCodePtr),                          // the REPL code, the return pointer.
@@ -320,7 +565,7 @@ impl CodePtr {
     pub fn local(&self) -> LocalCodePtr {
         match self {
             &CodePtr::BuiltInClause(_, ref local)
-          | &CodePtr::CallN(_, ref local)
+          | &CodePtr::CallN(_, ref local, _)
           | &CodePtr::Local(ref local) => local.clone(),
             &CodePtr::VerifyAttrInterrupt(p) => LocalCodePtr::DirEntry(p),
             &CodePtr::REPL(_, p) | &CodePtr::DynamicTransaction(_, p) => p,
@@ -328,7 +573,7 @@ impl CodePtr {
     }
 }
 
-#[derive(Copy, Clone, PartialEq)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 pub enum LocalCodePtr {
     DirEntry(usize), // offset.
     InSituDirEntry(usize),
@@ -338,19 +583,83 @@ pub enum LocalCodePtr {
 }
 
 impl LocalCodePtr {
-    pub fn assign_if_local(&mut self, cp: CodePtr) {
+    pub(crate)
+    fn assign_if_local(&mut self, cp: CodePtr) {
         match cp {
             CodePtr::Local(local) => *self = local,
             _ => {}
         }
     }
+
+    pub(crate)
+    fn is_reset_cont_marker(&self, code_repo: &CodeRepo, last_call: bool) -> bool {
+        match code_repo.lookup_instr(last_call, &CodePtr::Local(*self)) {
+            Some(line) => {
+                match line.as_ref() {
+                    Line::Control(ControlInstruction::CallClause(ref ct, ..)) => {
+                        if let ClauseType::System(SystemClauseType::ResetContinuationMarker) = *ct {
+                            return true;
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            None => {}
+        }
+
+        false
+    }
+
+    pub(crate)
+    fn as_functor<T: RawBlockTraits>(&self, heap: &mut HeapTemplate<T>) -> Addr {
+        let addr = Addr::HeapCell(heap.h());
+
+        match self {
+            LocalCodePtr::DirEntry(p) => {
+                heap.append(functor!(
+                    "dir_entry",
+                    [integer(*p)]
+                ));
+            }
+            LocalCodePtr::InSituDirEntry(p) => {
+                heap.append(functor!(
+                    "in_situ_dir_entry",
+                    [integer(*p)]
+                ));
+            }
+            LocalCodePtr::TopLevel(chunk_num, offset) => {
+                heap.append(functor!(
+                    "top_level",
+                    [integer(*chunk_num), integer(*offset)]
+                ));
+            }
+            LocalCodePtr::UserGoalExpansion(p) => {
+                heap.append(functor!(
+                    "user_goal_expansion",
+                    [integer(*p)]
+                ));
+            }
+            LocalCodePtr::UserTermExpansion(p) => {
+                heap.append(functor!(
+                    "user_term_expansion",
+                    [integer(*p)]
+                ));
+            }
+        }
+
+        addr
+    }
 }
 
 impl PartialOrd<CodePtr> for CodePtr {
     fn partial_cmp(&self, other: &CodePtr) -> Option<Ordering> {
         match (self, other) {
-            (&CodePtr::Local(ref l1), &CodePtr::Local(ref l2)) => l1.partial_cmp(l2),
-            _ => Some(Ordering::Greater),
+            (&CodePtr::Local(ref l1), &CodePtr::Local(ref l2)) => {
+                l1.partial_cmp(l2)
+            }
+            _ => {
+                Some(Ordering::Greater)
+            }
         }
     }
 }
@@ -365,8 +674,12 @@ impl PartialOrd<LocalCodePtr> for LocalCodePtr {
           | (&LocalCodePtr::TopLevel(_, p1), &LocalCodePtr::TopLevel(_, ref p2)) => {
                 p1.partial_cmp(p2)
             }
-            (_, &LocalCodePtr::TopLevel(_, _)) => Some(Ordering::Less),
-            _ => Some(Ordering::Greater),
+            (_, &LocalCodePtr::TopLevel(_, _)) => {
+                Some(Ordering::Less)
+            }
+            _ => {
+                Some(Ordering::Greater)
+            }
         }
     }
 }
@@ -397,6 +710,25 @@ impl Add<usize> for LocalCodePtr {
     }
 }
 
+impl Sub<usize> for LocalCodePtr {
+    type Output = Option<LocalCodePtr>;
+
+    fn sub(self, rhs: usize) -> Self::Output {
+        match self {
+            LocalCodePtr::InSituDirEntry(p) =>
+                p.checked_sub(rhs).map(LocalCodePtr::InSituDirEntry),
+            LocalCodePtr::DirEntry(p) =>
+                p.checked_sub(rhs).map(LocalCodePtr::DirEntry),
+            LocalCodePtr::TopLevel(cn, p) =>
+                p.checked_sub(rhs).map(|r| LocalCodePtr::TopLevel(cn, r)),
+            LocalCodePtr::UserTermExpansion(p) =>
+                p.checked_sub(rhs).map(LocalCodePtr::UserTermExpansion),
+            LocalCodePtr::UserGoalExpansion(p) =>
+                p.checked_sub(rhs).map(LocalCodePtr::UserGoalExpansion),
+        }
+    }
+}
+
 impl AddAssign<usize> for LocalCodePtr {
     fn add_assign(&mut self, rhs: usize) {
         match self {
@@ -418,7 +750,7 @@ impl Add<usize> for CodePtr {
           | p @ CodePtr::VerifyAttrInterrupt(_)
           | p @ CodePtr::DynamicTransaction(..) => p,
             CodePtr::Local(local) => CodePtr::Local(local + rhs),
-            CodePtr::CallN(_, local) | CodePtr::BuiltInClause(_, local) => {
+            CodePtr::BuiltInClause(_, local) | CodePtr::CallN(_, local, _) => {
                 CodePtr::Local(local + rhs)
             }
         }
@@ -452,19 +784,40 @@ impl Default for DynamicPredicateInfo {
 }
 
 pub type InSituCodeDir = IndexMap<PredicateKey, usize>;
+
 // key type: module name, predicate indicator.
 pub type DynamicCodeDir = IndexMap<(ClauseName, ClauseName, usize), DynamicPredicateInfo>;
 
 pub type GlobalVarDir = IndexMap<ClauseName, (Ball, Option<usize>)>;
 
+pub(crate) struct ModuleStub {
+    pub(crate) atom_tbl: TabledData<Atom>,
+    pub(crate) in_situ_code_dir: InSituCodeDir,
+}
+
+impl ModuleStub {
+    pub(crate) fn new(atom_tbl: TabledData<Atom>) -> Self {
+        ModuleStub {
+            atom_tbl,
+            in_situ_code_dir: InSituCodeDir::new(),
+        }
+    }
+}
+
+pub(crate) type ModuleStubDir = IndexMap<ClauseName, ModuleStub>;
+pub(crate) type StreamAliasDir = IndexMap<ClauseName, Stream>;
+
 pub struct IndexStore {
     pub(super) atom_tbl: TabledData<Atom>,
     pub(super) code_dir: CodeDir,
     pub(super) dynamic_code_dir: DynamicCodeDir,
     pub(super) global_variables: GlobalVarDir,
     pub(super) in_situ_code_dir: InSituCodeDir,
+    pub(super) in_situ_module_dir: ModuleStubDir,
+    pub(super) module_dir: ModuleDir,
     pub(super) modules: ModuleDir,
     pub(super) op_dir: OpDir,
+    pub(super) stream_aliases: StreamAliasDir,
 }
 
 impl IndexStore {
@@ -491,6 +844,19 @@ impl IndexStore {
         }
     }
 
+    pub fn add_term_and_goal_expansion_indices(&mut self) {
+        self.code_dir.insert((clause_name!("term_expansion"), 2),
+                             CodeIndex(Rc::new(RefCell::new(
+                                 (IndexPtr::UserTermExpansion,
+                                  clause_name!("user"))
+                             ))));
+        self.code_dir.insert((clause_name!("goal_expansion"), 2),
+                             CodeIndex(Rc::new(RefCell::new(
+                                 (IndexPtr::UserGoalExpansion,
+                                  clause_name!("user"))
+                             ))));
+    }
+
     #[inline]
     pub fn remove_clause_subsection(&mut self, module: ClauseName, name: ClauseName, arity: usize) {
         self.dynamic_code_dir.swap_remove(&(module, name, arity));
@@ -506,6 +872,16 @@ impl IndexStore {
         self.dynamic_code_dir.get(&(module, name, arity)).cloned()
     }
 
+    #[inline]
+    pub(crate) fn take_in_situ_module_dir(&mut self) -> ModuleStubDir {
+        mem::replace(&mut self.in_situ_module_dir, ModuleStubDir::new())
+    }
+
+    #[inline]
+    pub fn take_in_situ_code_dir(&mut self) -> InSituCodeDir {
+        mem::replace(&mut self.in_situ_code_dir, InSituCodeDir::new())
+    }
+
     #[inline]
     pub fn take_module(&mut self, name: ClauseName) -> Option<Module> {
         self.modules.swap_remove(&name)
@@ -521,12 +897,14 @@ impl IndexStore {
         IndexStore {
             atom_tbl: TabledData::new(Rc::new("user".to_string())),
             code_dir: CodeDir::new(),
+            module_dir: ModuleDir::new(),
             dynamic_code_dir: DynamicCodeDir::new(),
             global_variables: GlobalVarDir::new(),
             in_situ_code_dir: InSituCodeDir::new(),
+            in_situ_module_dir: ModuleStubDir::new(),
             op_dir: default_op_dir(),
             modules: ModuleDir::new(),
-            //            parsing_stream: readline::parsing_stream(String::new())
+            stream_aliases: StreamAliasDir::new(),
         }
     }
 
@@ -557,13 +935,13 @@ impl IndexStore {
         let r_w_h = clause_name!("run_cleaners_with_handling");
         let r_wo_h = clause_name!("run_cleaners_without_handling");
 
-        let non_iso = clause_name!("non_iso");
+        let iso_ext = clause_name!("iso_ext");
 
         let r_w_h = self
-            .get_internal(r_w_h, 0, non_iso.clone())
+            .get_internal(r_w_h, 0, iso_ext.clone())
             .and_then(|item| item.local());
         let r_wo_h = self
-            .get_internal(r_wo_h, 1, non_iso)
+            .get_internal(r_wo_h, 1, iso_ext)
             .and_then(|item| item.local());
 
         if let Some(r_w_h) = r_w_h {
@@ -579,6 +957,77 @@ impl IndexStore {
 pub type CodeDir = BTreeMap<PredicateKey, CodeIndex>;
 pub type TermDir = IndexMap<PredicateKey, (Predicate, VecDeque<TopLevel>)>;
 
+pub struct TermDirQuantumEntry {
+    pub old_terms: (Predicate, VecDeque<TopLevel>),
+    pub new_terms: (Predicate, VecDeque<TopLevel>),
+    pub is_fresh: bool,
+}
+
+impl TermDirQuantumEntry {
+    #[inline]
+    pub fn new() -> Self {
+        TermDirQuantumEntry {
+            old_terms: (Predicate::new(), VecDeque::new()),
+            new_terms: (Predicate::new(), VecDeque::new()),
+            is_fresh: false,
+        }
+    }
+
+    pub fn from(preds: &Predicate, queue: &VecDeque<TopLevel>) -> Self
+    {
+        let mut entry = TermDirQuantumEntry::new();
+        entry.is_fresh = false;
+
+        (entry.old_terms.0).0.extend(preds.0.iter().cloned());
+        entry.old_terms.1.extend(queue.iter().cloned());
+
+        entry
+    }
+}
+
+pub struct TermDirQuantum(IndexMap<PredicateKey, TermDirQuantumEntry>);
+
+impl TermDirQuantum {
+    #[inline]
+    pub fn new() -> Self {
+        TermDirQuantum(IndexMap::new())
+    }
+
+    #[inline]
+    pub fn insert_or_refresh(&mut self, key: PredicateKey, mut entry: TermDirQuantumEntry) {
+        if let Some(prev_entry) = self.get_mut(&key) {
+            prev_entry.is_fresh = true;
+        } else {
+            entry.is_fresh = true;
+            self.0.insert(key, entry);
+        }
+    }
+
+    #[inline]
+    pub fn insert(&mut self, key: PredicateKey, entry: TermDirQuantumEntry) {
+        self.0.insert(key, entry);
+    }
+
+    #[inline]
+    pub fn get_mut(&mut self, key: &PredicateKey) -> Option<&mut TermDirQuantumEntry> {
+        self.0.get_mut(key)
+    }
+
+    pub fn consolidate(self) -> TermDir {
+        let mut term_dir = TermDir::new();
+
+        for (key, entry) in self.0 {
+            let (preds, queue) =
+                term_dir.entry(key).or_insert((Predicate::new(), VecDeque::new()));
+
+            preds.0.extend((entry.new_terms.0).0.into_iter());
+            queue.extend(entry.new_terms.1.into_iter());
+        }
+
+        term_dir
+    }
+}
+
 #[derive(Clone, Copy, PartialEq, Eq, Ord, PartialOrd)]
 pub enum CompileTimeHook {
     GoalExpansion,

src/prolog/machine/modules.rs

@@ -7,28 +7,37 @@ use crate::prolog::machine::machine_errors::*;
 use crate::prolog::machine::machine_indices::*;
 
 use std::collections::VecDeque;
+use std::mem;
 
 // Module's and related types are defined in forms.
 impl Module {
-    pub fn new(module_decl: ModuleDecl, atom_tbl: TabledData<Atom>) -> Self
+    pub fn new(
+        module_decl: ModuleDecl,
+        atom_tbl: TabledData<Atom>,
+        listing_src: ListingSource,
+    ) -> Self
     {
         Module {
-            module_decl,
             atom_tbl,
+            module_decl,
+            term_dir: TermDir::new(),
             user_term_expansions: (Predicate::new(), VecDeque::from(vec![])),
             user_goal_expansions: (Predicate::new(), VecDeque::from(vec![])),
             term_expansions: (Predicate::new(), VecDeque::from(vec![])),
             goal_expansions: (Predicate::new(), VecDeque::from(vec![])),
+            local_term_expansions: (Predicate::new(), VecDeque::from(vec![])),
+            local_goal_expansions: (Predicate::new(), VecDeque::from(vec![])),
             code_dir: CodeDir::new(),
             op_dir: default_op_dir(),
             inserted_expansions: false,
+            is_impromptu_module: false,
+            listing_src,
         }
     }
 
     pub fn dump_expansions(
         &self,
         code_repo: &mut CodeRepo,
-        flags: MachineFlags,
     ) -> Result<(), ParserError> {
         {
             let te = code_repo
@@ -54,13 +63,13 @@ impl Module {
             ge.1.extend(self.user_goal_expansions.1.iter().cloned());
         }
 
-        code_repo.compile_hook(CompileTimeHook::TermExpansion, flags)?;
-        code_repo.compile_hook(CompileTimeHook::GoalExpansion, flags)?;
+        code_repo.compile_hook(CompileTimeHook::TermExpansion)?;
+        code_repo.compile_hook(CompileTimeHook::GoalExpansion)?;
 
         Ok(())
     }
 
-    pub fn add_module_expansion_record(
+    pub fn add_expansion_record(
         &mut self,
         hook: CompileTimeHook,
         clause: PredicateClause,
@@ -77,6 +86,35 @@ impl Module {
             }
         }
     }
+
+    pub fn add_local_expansion(
+        &mut self,
+        hook: CompileTimeHook,
+        clause: PredicateClause,
+        queue: VecDeque<TopLevel>,
+    ) {
+        match hook {
+            CompileTimeHook::TermExpansion => {
+                (self.local_term_expansions.0).0.push(clause);
+                self.local_term_expansions.1.extend(queue.into_iter());
+            }
+            CompileTimeHook::GoalExpansion => {
+                (self.local_goal_expansions.0).0.push(clause);
+                self.local_goal_expansions.1.extend(queue.into_iter());
+            }
+            _ => {}
+        }
+    }
+
+    pub fn take_local_expansions(&mut self) -> Vec<(Predicate, VecDeque<TopLevel>)>
+    {
+        let term_expansions =
+            mem::replace(&mut self.local_term_expansions, (Predicate::new(), VecDeque::new()));
+        let goal_expansions =
+            mem::replace(&mut self.local_goal_expansions, (Predicate::new(), VecDeque::new()));
+
+        vec![term_expansions, goal_expansions]
+    }
 }
 
 pub trait SubModuleUser {
@@ -94,64 +132,55 @@ pub trait SubModuleUser {
     }
 
     fn remove_module(&mut self, mod_name: ClauseName, module: &Module) {
-        for (name, arity) in module.module_decl.exports.iter().cloned() {
-            let name = name.defrock_brackets();
+        for export in module.module_decl.exports.iter().cloned() {
+            match export {
+                ModuleExport::PredicateKey((name, arity)) => {
+                    let name = name.defrock_brackets();
 
-            match self.get_code_index((name.clone(), arity), mod_name.clone()) {
-                Some(CodeIndex(ref code_idx)) => {
-                    if &code_idx.borrow().1 != &module.module_decl.name {
-                        continue;
-                    }
-
-                    self.remove_code_index((name.clone(), arity));
-
-                    // remove or respecify ops.
-                    if arity == 2 {
-                        if let Some(mod_name) = self.get_op_module_name(name.clone(), Fixity::In) {
-                            if mod_name == module.module_decl.name {
-                                self.op_dir().remove(&(name.clone(), Fixity::In));
+                    match self.get_code_index((name.clone(), arity), mod_name.clone()) {
+                        Some(CodeIndex(ref code_idx)) => {
+                            if &code_idx.borrow().1 != &module.module_decl.name {
+                                continue;
                             }
-                        }
-                    } else if arity == 1 {
-                        if let Some(mod_name) = self.get_op_module_name(name.clone(), Fixity::Pre) {
-                            if mod_name == module.module_decl.name {
-                                self.op_dir().remove(&(name.clone(), Fixity::Pre));
-                            }
-                        }
 
-                        if let Some(mod_name) = self.get_op_module_name(name.clone(), Fixity::Post)
-                        {
-                            if mod_name == module.module_decl.name {
-                                self.op_dir().remove(&(name.clone(), Fixity::Post));
+                            self.remove_code_index((name.clone(), arity));
+
+                            // remove or respecify ops.
+                            if arity == 2 {
+                                if let Some(mod_name) = self.get_op_module_name(name.clone(), Fixity::In) {
+                                    if mod_name == module.module_decl.name {
+                                        self.op_dir().remove(&(name.clone(), Fixity::In));
+                                    }
+                                }
+                            } else if arity == 1 {
+                                if let Some(mod_name) = self.get_op_module_name(name.clone(), Fixity::Pre) {
+                                    if mod_name == module.module_decl.name {
+                                        self.op_dir().remove(&(name.clone(), Fixity::Pre));
+                                    }
+                                }
+
+                                if let Some(mod_name) = self.get_op_module_name(name.clone(), Fixity::Post)
+                                {
+                                    if mod_name == module.module_decl.name {
+                                        self.op_dir().remove(&(name.clone(), Fixity::Post));
+                                    }
+                                }
                             }
-                        }
-                    }
+                        }                    
+                        _ => {}
+                    };
+                },
+                ModuleExport::OpDecl(op_decl) => {
+                    let op_dir = self.op_dir();
+                    op_dir.remove(&(op_decl.name(), op_decl.fixity()));
                 }
-                _ => {}
-            };
+            }
         }
     }
 
     // returns true on successful import.
     fn import_decl(&mut self, name: ClauseName, arity: usize, submodule: &Module) -> bool {
         let name = name.defrock_brackets();
-        let mut found_op = false;
-
-        {
-            let mut insert_op_dir = |fix| {
-                if let Some(op_data) = submodule.op_dir.get(&(name.clone(), fix)) {
-                    self.op_dir().insert((name.clone(), fix), op_data.clone());
-                    found_op = true;
-                }
-            };
-
-            if arity == 1 {
-                insert_op_dir(Fixity::Pre);
-                insert_op_dir(Fixity::Post);
-            } else if arity == 2 {
-                insert_op_dir(Fixity::In);
-            }
-        }
 
         if let Some(code_data) = submodule.code_dir.get(&(name.clone(), arity)) {
             let name = name.with_table(submodule.atom_tbl.clone());
@@ -162,7 +191,7 @@ pub trait SubModuleUser {
             self.insert_dir_entry(name, arity, code_data.clone());
             true
         } else {
-            found_op
+            submodule.is_impromptu_module
         }
     }
 
@@ -171,30 +200,63 @@ pub trait SubModuleUser {
         _: &mut CodeRepo,
         _: MachineFlags,
         _: &Module,
-        _: &Vec<PredicateKey>,
+        _: &Vec<ModuleExport>,
+    ) -> Result<(), SessionError>;
+    
+    fn use_module(
+        &mut self,
+        _: &mut CodeRepo,
+        _: MachineFlags,
+        _: &Module
     ) -> Result<(), SessionError>;
-    fn use_module(&mut self, _: &mut CodeRepo, _: MachineFlags, _: &Module) -> Result<(), SessionError>;
 }
 
 pub fn use_qualified_module<User>(
     user: &mut User,
     submodule: &Module,
-    exports: &Vec<PredicateKey>,
+    exports: &Vec<ModuleExport>,
 ) -> Result<(), SessionError>
 where
     User: SubModuleUser,
 {
-    for (name, arity) in exports.iter().cloned() {
-        if !submodule
-            .module_decl
-            .exports
-            .contains(&(name.clone(), arity))
-        {
-            continue;
-        }
+    for export in exports.iter().cloned() {
+        match export {
+            ModuleExport::PredicateKey((name, arity)) => {
+                if !submodule
+                    .module_decl
+                    .exports
+                    .contains(&ModuleExport::PredicateKey((name.clone(), arity)))
+                {
+                    continue;
+                }
 
-        if !user.import_decl(name, arity, submodule) {
-            return Err(SessionError::ModuleDoesNotContainExport);
+                if !user.import_decl(name.clone(), arity, submodule) {
+                    let submodule_name = submodule.module_decl.name.clone();
+                    
+                    return Err(SessionError::ModuleDoesNotContainExport(
+                        submodule_name,
+                        (name, arity)
+                    ));
+                }
+            },
+            ModuleExport::OpDecl(op_decl) => {
+                if !submodule
+                    .module_decl
+                    .exports
+                    .contains(&ModuleExport::OpDecl(op_decl.clone()))
+                {
+                    continue;
+                }
+
+                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,
+                );                   
+            }
         }
     }
 
@@ -205,9 +267,28 @@ pub fn use_module<User: SubModuleUser>(
     user: &mut User,
     submodule: &Module,
 ) -> Result<(), SessionError> {
-    for (name, arity) in submodule.module_decl.exports.iter().cloned() {
-        if !user.import_decl(name, arity, submodule) {
-            return Err(SessionError::ModuleDoesNotContainExport);
+    for export in submodule.module_decl.exports.iter().cloned() {
+        match export {
+            ModuleExport::PredicateKey((name, arity)) => {
+                if !user.import_decl(name.clone(), arity, submodule) {
+                    let submodule_name = submodule.module_decl.name.clone();
+
+                    return Err(SessionError::ModuleDoesNotContainExport(
+                        submodule_name,
+                        (name, arity)
+                    ));
+                }
+            }
+            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,
+                );                
+            }
         }
     }
 
@@ -240,7 +321,7 @@ impl SubModuleUser for Module {
         _: &mut CodeRepo,
         _: MachineFlags,
         submodule: &Module,
-        exports: &Vec<PredicateKey>,
+        exports: &Vec<ModuleExport>,
     ) -> Result<(), SessionError> {
         use_qualified_module(self, submodule, exports)?;
 
@@ -282,7 +363,7 @@ impl SubModuleUser for Module {
         self.user_goal_expansions
             .1
             .extend(submodule.goal_expansions.1.iter().cloned());
-	
+
         Ok(())
     }
 }

src/prolog/machine/or_stack.rs

@@ -1,145 +0,0 @@
-use crate::prolog::machine::machine_indices::*;
-
-use std::mem;
-use std::ops::{Index, IndexMut};
-use std::vec::Vec;
-
-pub struct Frame {
-    pub global_index: usize,
-    pub e: usize,
-    pub cp: LocalCodePtr,
-    pub attr_var_init_b: usize,
-    pub b: usize,
-    pub bp: CodePtr,
-    pub tr: usize,
-    pub pstr_tr: usize,
-    pub h: usize,
-    pub b0: usize,
-    args: Vec<Addr>,
-}
-
-impl Frame {
-    fn new(
-        global_index: usize,
-        e: usize,
-        cp: LocalCodePtr,
-        attr_var_init_b: usize,
-        b: usize,
-        bp: CodePtr,
-        tr: usize,
-        pstr_tr: usize,
-        h: usize,
-        b0: usize,
-        n: usize,
-    ) -> Self {
-        Frame {
-            global_index,
-            e,
-            cp,
-            attr_var_init_b,
-            b,
-            bp,
-            tr,
-            pstr_tr,
-            h,
-            b0,
-            args: vec![Addr::HeapCell(0); n],
-        }
-    }
-
-    pub fn num_args(&self) -> usize {
-        self.args.len()
-    }
-}
-
-pub struct OrStack(Vec<Frame>);
-
-impl OrStack {
-    pub fn new() -> Self {
-        OrStack(Vec::new())
-    }
-
-    pub fn push(
-        &mut self,
-        global_index: usize,
-        e: usize,
-        cp: LocalCodePtr,
-        attr_var_init_b: usize,
-        b: usize,
-        bp: CodePtr,
-        tr: usize,
-        pstr_tr: usize,
-        h: usize,
-        b0: usize,
-        n: usize,
-    ) {
-        self.0.push(Frame::new(
-            global_index,
-            e,
-            cp,
-            attr_var_init_b,
-            b,
-            bp,
-            tr,
-            pstr_tr,
-            h,
-            b0,
-            n,
-        ));
-    }
-
-    #[inline]
-    pub(crate) fn take(&mut self) -> Self {
-        OrStack(mem::replace(&mut self.0, vec![]))
-    }
-
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    pub fn clear(&mut self) {
-        self.0.clear()
-    }
-
-    pub fn top(&self) -> Option<&Frame> {
-        self.0.last()
-    }
-
-    // truncate expects a 1-indexed new_b, ie.
-    // the value b of MachineState.
-    pub fn truncate(&mut self, new_b: usize) {
-        self.0.truncate(new_b);
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-}
-
-impl Index<usize> for OrStack {
-    type Output = Frame;
-
-    fn index(&self, index: usize) -> &Self::Output {
-        self.0.index(index)
-    }
-}
-
-impl IndexMut<usize> for OrStack {
-    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
-        self.0.index_mut(index)
-    }
-}
-
-impl Index<usize> for Frame {
-    type Output = Addr;
-
-    fn index(&self, index: usize) -> &Self::Output {
-        self.args.index(index - 1)
-    }
-}
-
-impl IndexMut<usize> for Frame {
-    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
-        self.args.index_mut(index - 1)
-    }
-}

src/prolog/machine/partial_string.rs

@@ -0,0 +1,238 @@
+use core::marker::PhantomData;
+
+use std::alloc;
+use std::mem;
+use std::ptr;
+use std::ops::RangeFrom;
+use std::slice;
+use std::str;
+
+pub struct PartialString {
+    buf: *const u8,
+    len: usize,
+    _marker: PhantomData<[u8]>,
+}
+
+impl Drop for PartialString {
+    fn drop(&mut self) {
+        unsafe {
+            let layout = alloc::Layout::from_size_align_unchecked(self.len, mem::align_of::<u8>());
+            alloc::dealloc(self.buf as *mut u8, layout);
+
+            self.buf = ptr::null();
+            self.len = 0;
+        }
+    }
+}
+
+impl Clone for PartialString {
+    #[inline]
+    fn clone(&self) -> Self {
+        self.clone_from_offset(0)
+    }
+}
+
+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;
+        }
+
+        terminator_idx += c.len_utf8();
+    }
+
+    terminator_idx
+}
+
+pub struct PStrIter {
+    buf: *const u8,
+}
+
+impl PStrIter {
+    #[inline]
+    fn from(buf: *const u8, idx: usize) -> Self {
+        PStrIter {
+            buf: (buf as usize + idx) as *const _
+        }
+    }
+}
+
+impl Iterator for PStrIter {
+    type Item = char;
+
+    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 s = str::from_utf8(slice).unwrap();
+
+            if let Some(c) = s.chars().next() {
+                self.buf = self.buf.offset(c.len_utf8() as isize);
+                Some(c)
+            } else {
+                None
+            }
+        }
+    }
+}
+
+impl PartialString {
+    #[inline]
+    pub(super)
+    fn new(src: &str) -> Option<(Self, &str)> {
+        let pstr = PartialString {
+            buf: ptr::null_mut(),
+            len: 0,
+            _marker: PhantomData,
+        };
+
+        unsafe {
+            pstr.append_chars(src)
+        }
+    }
+
+    #[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>(),
+        );
+
+        self.buf = alloc::alloc(layout) as *const _;
+        self.len = terminator_idx + '\u{0}'.len_utf8();
+
+        ptr::copy(
+            src.as_ptr(),
+            self.buf as *mut _,
+            terminator_idx,
+        );
+
+        self.write_terminator_at(terminator_idx);
+
+        Some(if terminator_idx != src.len() {
+            (self, &src[terminator_idx + '\u{0}'.len_utf8() ..])
+        } else {
+            (self, "")
+        })
+    }
+
+    pub(super)
+    fn clone_from_offset(&self, n: usize) -> Self {
+        let len =
+            if self.len - '\u{0}'.len_utf8() > n {
+                self.len - n - '\u{0}'.len_utf8()
+            } else {
+                0
+            };
+
+        let mut pstr = PartialString {
+            buf: ptr::null_mut(),
+            len: len + '\u{0}'.len_utf8(),
+            _marker: PhantomData,
+        };
+
+        unsafe {
+            let layout = alloc::Layout::from_size_align_unchecked(
+                len + '\u{0}'.len_utf8(),
+                mem::align_of::<u8>(),
+            );
+
+            pstr.buf = alloc::alloc(layout);
+
+            if len > 0 {
+                ptr::copy(
+                    (self.buf as usize + n) as *const u8,
+                    pstr.buf as *mut _,
+                    len,
+                );
+            }
+
+            pstr.write_terminator_at(len);
+        }
+
+        pstr
+    }
+
+    #[inline]
+    pub(super)
+    fn write_terminator_at(&mut self, index: usize) {
+        unsafe {
+            ptr::write(
+                (self.buf as usize + index) as *mut u8,
+                0u8,
+            );
+        }
+    }
+
+    #[inline]
+    pub fn range_from(&self, index: RangeFrom<usize>) -> PStrIter {
+        PStrIter::from(self.buf, index.start)
+    }
+
+    #[inline]
+    pub fn at_end(&self, end_n: usize) -> bool {
+        unsafe {
+            ptr::read((self.buf as usize + end_n) as *const u8) == 0u8
+        }
+    }
+
+    #[inline]
+    pub fn as_str_from(&self, n: usize) -> &str {
+        unsafe {
+            let slice = slice::from_raw_parts(
+                self.buf,
+                self.len - '\u{0}'.len_utf8(),
+            );
+
+            let s = str::from_utf8(slice).unwrap();
+
+            &s[n ..]
+        }
+    }
+}

src/prolog/machine/project_attributes.pl

@@ -1,10 +1,9 @@
-driver(QueryVars, AttrVars) :-
+'$attribute_goals_driver'(QueryVars, AttrVars) :-
     gather_modules(AttrVars, Modules0, _),
     sort(Modules0, Modules),
     call_project_attributes(Modules, QueryVars, AttrVars),
     call_attribute_goals(Modules, call_query_var_goals, QueryVars),
-    call_attribute_goals(Modules, call_attr_var_goals, AttrVars),
-    '$return_from_attribute_goals'.
+    call_attribute_goals(Modules, call_attr_var_goals, AttrVars).
 
 enqueue_goals(Goals0) :-
     nonvar(Goals0),
@@ -50,8 +49,8 @@ call_attribute_goals([Module | Modules], GoalCaller, AttrVars) :-
 
 call_query_var_goals([], _, []).
 call_query_var_goals([AttrVar|AttrVars], Module, Goals) :-
-    (  catch((  Module:attribute_goals(AttrVar, Goals, RGoals0),
-	        atts:'$default_attr_list'(Module, AttrVar, RGoals0, RGoals)
+    (  catch((  Module:attribute_goals(AttrVar, Goals, RGoals0)
+	     ,  atts:'$default_attr_list'(Module, AttrVar, RGoals0, RGoals)
 	     ),
 	     E,
 	     (  '$print_attribute_goals_exception'(Module, E),
@@ -64,7 +63,7 @@ call_query_var_goals([AttrVar|AttrVars], Module, Goals) :-
 
 call_attr_var_goals([], _, []).
 call_attr_var_goals([AttrVar|AttrVars], Module, Goals) :-
-    (  catch(Module:attribute_goals(AttrVar, Goals, RGoals),	        	     
+    (  catch(Module:attribute_goals(AttrVar, Goals, RGoals),
 	     E,
 	     '$print_attribute_goals_exception'(Module, E)
 	     )
@@ -84,3 +83,26 @@ gather_modules_for_attrs(Attrs, Modules, Modules) :-
 gather_modules_for_attrs([Attr|Attrs], [Module|Modules], Modules0) :-
     '$module_of'(Module, Attr),
     gather_modules_for_attrs(Attrs, Modules, Modules0).
+
+module_prefixed_goals([], _, Gs, Gs).
+module_prefixed_goals([G|Gs], Module, [MG|MGs], TailGs) :-
+    (  G = _:_ -> MG = G
+    ;  MG = Module:G
+    ),
+    module_prefixed_goals(Gs, Module, MGs, TailGs).
+
+call_attribute_goals_with_module_prefix([], _, _, []).
+call_attribute_goals_with_module_prefix([Module | Modules], GoalCaller, AttrVars, Goals) :-
+    call(GoalCaller, AttrVars, Module, Goals0),
+    enqueue_goals(Goals0),
+    module_prefixed_goals(Goals0, Module, Goals, Gs),
+    call_attribute_goals_with_module_prefix(Modules, GoalCaller, AttrVars, Gs).
+
+copy_term(Source, Dest, Goals) :-
+    term_variables(Source, Vars),
+    gather_modules(Vars, Modules0, _),
+    sort(Modules0, Modules),
+    call_attribute_goals_with_module_prefix(Modules, call_query_var_goals, Vars, Goals0),
+    sort(Goals0, Goals1),
+    !,
+    '$copy_term_without_attr_vars'([Source | Goals1], [Dest | Goals]).

src/prolog/machine/raw_block.rs

@@ -0,0 +1,108 @@
+use core::marker::PhantomData;
+
+use std::alloc;
+use std::mem;
+use std::ptr;
+
+pub(crate) trait RawBlockTraits {
+    fn init_size() -> usize;
+    fn align() -> usize;
+
+    #[inline]
+    fn base_offset(base: *const u8) -> *const u8 {
+        base
+    }
+}
+
+pub(crate) struct RawBlock<T: RawBlockTraits> {
+    pub(crate) size: usize,
+    pub(crate) base: *const u8,
+    pub(crate) top: *const u8,
+    _marker: PhantomData<T>,
+}
+
+impl<T: RawBlockTraits> RawBlock<T> {
+    pub(crate)
+    fn new() -> Self {
+        let mut block = RawBlock { size: 0,
+                                   base: ptr::null(),
+                                   top: ptr::null(),
+                                   _marker: PhantomData };
+
+        unsafe {
+            block.grow();
+        }
+
+        block
+    }
+
+    unsafe fn init_at_size(&mut self, cap: usize) {
+        let layout = alloc::Layout::from_size_align_unchecked(cap, T::align());
+
+        self.base = alloc::alloc(layout) as *const _;
+        self.size = cap;
+
+        self.top = T::base_offset(self.base);
+    }
+
+    pub(super)
+    unsafe fn grow(&mut self) {
+        if self.size == 0 {
+            self.init_at_size(T::init_size());
+        } else {
+            let layout = alloc::Layout::from_size_align_unchecked(T::init_size(), T::align());
+            let top_dist = self.top as usize - self.base as usize;
+
+            self.base = alloc::realloc(self.base as *mut _, layout, self.size*2) as *const _;
+            self.top = (self.base as usize + top_dist) as *const _;
+            self.size *= 2;
+        }
+    }
+
+    fn empty_block() -> Self {
+        RawBlock { size: 0,
+                 base: ptr::null(),
+                 top: ptr::null(),
+                 _marker: PhantomData }
+    }
+
+    #[inline]
+    pub(crate)
+    fn take(&mut self) -> Self {
+        mem::replace(self, Self::empty_block())
+    }
+
+    #[inline]
+    fn free_space(&self) -> usize {
+        debug_assert!(self.top >= self.base,
+                      "self.top = {:?} < {:?} = self.base",
+                      self.top, self.base);
+
+        self.size - (self.top as usize - self.base as usize)
+    }
+
+    #[inline]
+    pub(crate)
+    unsafe fn new_block(&mut self, size: usize) -> *const u8 {
+        loop {
+            if self.free_space() >= size {
+                return (self.top as usize + size) as *const _;
+            } else {
+                self.grow();
+            }
+        }
+    }
+
+    pub(crate)
+    fn deallocate(&mut self) {
+        unsafe {
+            let layout = alloc::Layout::from_size_align_unchecked(self.size, T::align());
+
+            alloc::dealloc(self.base as *mut u8, layout);
+
+            self.top  = ptr::null();
+            self.base = ptr::null();
+            self.size = 0;
+        }
+    }
+}

src/prolog/machine/stack.rs

@@ -0,0 +1,268 @@
+use crate::prolog::machine::machine_indices::*;
+use crate::prolog::machine::raw_block::*;
+
+use core::marker::PhantomData;
+
+use std::mem;
+use std::ops::{Index, IndexMut};
+use std::ptr;
+
+struct StackTraits {}
+
+impl RawBlockTraits for StackTraits {
+    #[inline]
+    fn init_size() -> usize {
+        10 * 1024 * 1024
+    }
+
+    #[inline]
+    fn align() -> usize {
+        mem::align_of::<Addr>()
+    }
+
+    #[inline]
+    fn base_offset(base: *const u8) -> *const u8 {
+        unsafe {
+            base.offset(Self::align() as isize)
+        }
+    }
+}
+
+const fn prelude_size<Prelude>() -> usize {
+    let size = mem::size_of::<Prelude>();
+    let align = mem::align_of::<Addr>();
+
+    (size & !(align - 1)) + align
+}
+
+pub struct Stack {
+    buf: RawBlock<StackTraits>,
+    _marker: PhantomData<Addr>,
+}
+
+impl Drop for Stack {
+    fn drop(&mut self) {
+        self.drop_in_place();
+        self.buf.deallocate();
+    }
+}
+
+#[derive(Clone, Copy)]
+pub struct FramePrelude {
+    pub num_cells: usize,
+}
+
+pub struct AndFramePrelude {
+    pub univ_prelude: FramePrelude,
+    pub e: usize,
+    pub cp: LocalCodePtr,
+    pub interrupt_cp: LocalCodePtr,
+}
+
+pub struct AndFrame {
+    pub prelude: AndFramePrelude,
+}
+
+impl AndFrame {
+    pub fn size_of(num_cells: usize) -> usize {
+        prelude_size::<AndFramePrelude>() + num_cells * mem::size_of::<Addr>()
+    }
+}
+
+impl Index<usize> for AndFrame {
+    type Output = Addr;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        let prelude_offset = prelude_size::<AndFramePrelude>();
+        let index_offset = (index - 1) * mem::size_of::<Addr>();
+
+        unsafe {
+            let ptr = mem::transmute::<&AndFrame, *const u8>(self);
+            let ptr = ptr as usize + prelude_offset + index_offset;
+
+            &*(ptr as *const Addr)
+        }
+    }
+}
+
+impl IndexMut<usize> for AndFrame {
+    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+        let prelude_offset = prelude_size::<AndFramePrelude>();
+        let index_offset = (index - 1) * mem::size_of::<Addr>();
+
+        unsafe {
+            let ptr = mem::transmute::<&mut AndFrame, *const u8>(self);
+            let ptr = ptr as usize + prelude_offset + index_offset;
+
+            &mut *(ptr as *mut Addr)
+        }
+    }
+}
+
+pub struct OrFramePrelude {
+    pub univ_prelude: FramePrelude,
+    pub e: usize,
+    pub cp: LocalCodePtr,
+    pub b: usize,
+    pub bp: LocalCodePtr,
+    pub tr: usize,
+    pub pstr_tr: usize,
+    pub h: usize,
+    pub b0: usize,
+    pub attr_var_init_queue_b: usize,
+    pub attr_var_init_bindings_b: usize,
+}
+
+pub struct OrFrame {
+    pub prelude: OrFramePrelude,
+}
+
+impl Index<usize> for OrFrame {
+    type Output = Addr;
+
+    #[inline]
+    fn index(&self, index: usize) -> &Self::Output {
+        let prelude_offset = prelude_size::<OrFramePrelude>();
+        let index_offset = index * mem::size_of::<Addr>();
+
+        unsafe {
+            let ptr = mem::transmute::<&OrFrame, *const u8>(self);
+            let ptr = ptr as usize + prelude_offset + index_offset;
+
+            &*(ptr as *const Addr)
+        }
+    }
+}
+
+impl IndexMut<usize> for OrFrame {
+    #[inline]
+    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+        let prelude_offset = prelude_size::<OrFramePrelude>();
+        let index_offset = index * mem::size_of::<Addr>();
+
+        unsafe {
+            let ptr = mem::transmute::<&mut OrFrame, *const u8>(self);
+            let ptr = ptr as usize + prelude_offset + index_offset;
+
+            &mut *(ptr as *mut Addr)
+        }
+    }
+}
+
+impl OrFrame {
+    pub fn size_of(num_cells: usize) -> usize {
+        prelude_size::<OrFramePrelude>() + num_cells * mem::size_of::<Addr>()
+    }
+}
+
+impl Stack {
+    pub fn new() -> Self {
+        Stack { buf: RawBlock::new(), _marker: PhantomData }
+    }
+
+    pub fn allocate_and_frame(&mut self, num_cells: usize) -> usize {
+        let frame_size = AndFrame::size_of(num_cells);
+
+        unsafe {
+            let new_top = self.buf.new_block(frame_size);
+
+            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));
+            }
+
+            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
+        }
+    }
+
+    pub fn allocate_or_frame(&mut self, num_cells: usize) -> usize {
+        let frame_size = OrFrame::size_of(num_cells);
+
+        unsafe {
+            let new_top = self.buf.new_block(frame_size);
+
+            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));
+            }
+
+            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
+        }
+    }
+
+    #[inline]
+    pub fn index_and_frame(&self, e: usize) -> &AndFrame {
+        unsafe {
+            let ptr = self.buf.base as usize + e;
+            &*(ptr as *const AndFrame)
+        }
+    }
+
+    #[inline]
+    pub fn index_and_frame_mut(&mut self, e: usize) -> &mut AndFrame {
+        unsafe {
+            let ptr = self.buf.base as usize + e;
+            &mut *(ptr as *mut AndFrame)
+        }
+    }
+
+    #[inline]
+    pub fn index_or_frame(&self, b: usize) -> &OrFrame {
+        unsafe {
+            let ptr = self.buf.base as usize + b;
+            &*(ptr as *const OrFrame)
+        }
+    }
+
+    #[inline]
+    pub fn index_or_frame_mut(&mut self, b: usize) -> &mut OrFrame {
+        unsafe {
+            let ptr = self.buf.base as usize + b;
+            &mut *(ptr as *mut OrFrame)
+        }
+    }
+
+    pub fn take(&mut self) -> Self {
+        Stack { buf: self.buf.take(), _marker: PhantomData }
+    }
+
+    #[inline]
+    pub fn truncate(&mut self, b: usize) {
+        if b == 0 {
+            self.inner_truncate(mem::align_of::<Addr>());
+        } else {
+            self.inner_truncate(b);
+        }
+    }
+
+    #[inline]
+    fn inner_truncate(&mut self, b: usize) {
+        let base = b + self.buf.base as usize;
+
+        if base < self.buf.top as usize {
+            self.buf.top = base as *const _;
+        }
+    }
+
+    pub fn drop_in_place(&mut self) {
+        self.truncate(mem::align_of::<Addr>());
+
+        debug_assert!(if self.buf.top.is_null() {
+            self.buf.top == self.buf.base
+        } else {
+            self.buf.top as usize == self.buf.base as usize + mem::align_of::<Addr>()
+        });
+    }
+}