move print_constant logic to heap_print.rs

diff --git a/README.md b/README.md
index 6a4ddf1670194275da214d63c4fde29b49ba1997..eb04d83ee7e9dd551d3f4c3537c929135ab3bd86 100644 (file)
--- a/README.md
+++ b/README.md
@@ -134,7 +134,6 @@ The following predicates are built-in to rusty-wam.
 * `compare/3`
 * `compound/1`
 * `cyclic_term/1`
-* `display/1`
 * `duplicate_term/2`
 * `false/0`
 * `float/1`
@@ -158,6 +157,7 @@ The following predicates are built-in to rusty-wam.
 * `throw/1`
 * `true/0`
 * `var/1`
+* `writeq/1`
 
 ## Tutorial
 To enter a multi-clause predicate, the brackets ":{" and "}:" are used

diff --git a/src/prolog/heap_print.rs b/src/prolog/heap_print.rs
index dfff11cbe53d6f8d53e87810fed4447a748dd42c..e09cc02019321dd200fe4281c91646e4175b0905 100644 (file)
--- a/src/prolog/heap_print.rs
+++ b/src/prolog/heap_print.rs
@@ -1,6 +1,7 @@
 use prolog::ast::*;
 use prolog::heap_iter::*;
 use prolog::machine::machine_state::MachineState;
+use prolog::ordered_float::OrderedFloat;
 
 use std::cell::Cell;
 use std::collections::{HashMap, HashSet};
@@ -233,9 +234,26 @@ impl<'a, Formatter: HCValueFormatter, Outputter: HCValueOutputter>
             }
         })
     }
+    
+    fn print_atom(&mut self, atom: &ClauseName) {
+        let non_quoted_token = |c| {
+            graphic_token_char!(c) || alpha_numeric_char!(c)
+        };
 
+        match atom.as_str() {
+            ";" | "!" => self.outputter.append(atom.as_str()),
+            s => if s.chars().all(non_quoted_token) {
+                self.outputter.append(atom.as_str());
+            } else {
+                self.outputter.append(&("'".to_owned() + atom.as_str() + "'"));
+            }
+        }
+    }
+    
     fn print_constant(&mut self, c: Constant) {
         match c {
+            Constant::Atom(ref atom) =>
+                self.print_atom(atom),
             Constant::Char(c) if c == '\n' =>
                 self.outputter.append("'\\n'"),
             Constant::Char(c) if c == '\r' =>
@@ -255,8 +273,23 @@ impl<'a, Formatter: HCValueFormatter, Outputter: HCValueOutputter>
                 self.outputter.push_char(c);
                 self.outputter.append("'");
             },
-            _ =>
-                self.outputter.append(format!("{}", c).as_str())
+            Constant::EmptyList =>
+                self.outputter.append("[]"),
+            Constant::Number(Number::Float(fl)) =>
+                if &fl == &OrderedFloat(0f64) {
+                    self.outputter.append("0");
+                } else {
+                    self.outputter.append(&format!("{}", fl));
+                },
+            Constant::Number(n) =>
+                self.outputter.append(&format!("{}", n)),
+            Constant::String(s) => {
+                self.outputter.append("\"");
+                self.outputter.append(s.as_str());
+                self.outputter.append("\"");
+            },
+            Constant::Usize(i) =>
+                self.outputter.append(&format!("u{}", i))
         }
     }
     

diff --git a/src/prolog/io.rs b/src/prolog/io.rs
index d162bc952e78f5624ff0f2b17b357145289a3b5e..71fdde36f8fe0ef6c4f9e320b023cb91e26c55e9 100644 (file)
--- a/src/prolog/io.rs
+++ b/src/prolog/io.rs
@@ -23,32 +23,25 @@ impl fmt::Display for IndexPtr {
     }
 }
 
-impl fmt::Display for Constant {
+impl fmt::Display for ClauseName {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fn print_atom(f: &mut fmt::Formatter, atom: &ClauseName) -> fmt::Result {
-            let non_quoted_token = |c| {
-                graphic_token_char!(c) || alpha_numeric_char!(c)
-            };
-
-            match atom.as_str() {
-                ";" | "!" => write!(f, "{}", atom.as_str()),
-                s => if s.chars().all(non_quoted_token) {
-                    write!(f, "{}", atom.as_str())
-                } else {
-                    write!(f, "{}", "'".to_owned() + atom.as_str() + "'")
-                }
-            }
-        }
+        write!(f, "{}", self.as_str())
+    }
+}
 
+impl fmt::Display for Constant {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             &Constant::Atom(ref atom) =>
-                print_atom(f, atom),
+                if atom.as_str().chars().any(|c| "`.$'\" ".contains(c)) {
+                    write!(f, "'{}'", atom.as_str())
+                } else {
+                    write!(f, "{}", atom.as_str())
+                },
             &Constant::Char(c) =>
                 write!(f, "'{}'", c as u8),
             &Constant::EmptyList =>
                 write!(f, "[]"),
-            &Constant::Number(Number::Float(ref fl)) if fl == &OrderedFloat(0f64) =>
-                write!(f, "0"),
             &Constant::Number(ref n) =>
                 write!(f, "{}", n),
             &Constant::String(ref s) =>
@@ -59,12 +52,6 @@ impl fmt::Display for Constant {
     }
 }
 
-impl fmt::Display for ClauseName {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.as_str())
-    }
-}
-
 impl fmt::Display for FactInstruction {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {

diff --git a/src/prolog/mod.rs b/src/prolog/mod.rs
index e6209c326a2e84d1c5bc81d33c8d2ae758290846..13412102406f8fadf0a7df95d53769a04955228e 100644 (file)
--- a/src/prolog/mod.rs
+++ b/src/prolog/mod.rs
@@ -17,12 +17,12 @@ pub mod copier;
 pub mod debray_allocator;
 pub mod fixtures;
 pub mod heap_iter;
-pub mod heap_print;
 pub mod indexing;
+pub mod io;
 pub mod iterators;
 pub mod or_stack;
 #[macro_use]
 pub mod parser;
-pub mod io;
+pub mod heap_print;
 pub mod targets;
 pub mod tabled_rc;

diff --git a/src/tests.rs b/src/tests.rs
index 8f1eff71912077a7ad16fa677853946d28a41015..9f9c059b9dd5e68b10cc9499e5992680a1ede58e 100644 (file)
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -1607,7 +1607,7 @@ fn test_queries_on_setup_call_cleanup()
     assert_prolog_failure!(&mut wam,
                            "?- setup_call_cleanup(S=1,(G=2;G=3), writeq(S+G>B)), B=4, !, throw(x).");
     assert_prolog_success!(&mut wam,
-                           "?- setup_call_cleanup(true, (X=1;X=2), writeq(a)), setup_call_cleanup(true,(Y=1;Y=2),writeq(b)), !.",
+"?- setup_call_cleanup(true, (X=1;X=2), writeq(a)), setup_call_cleanup(true,(Y=1;Y=2),writeq(b)), !.",
                            [["Y = 1", "X = 1"]]);
     assert_prolog_success!(&mut wam, "?- catch(setup_call_cleanup(true,throw(goal),throw(cl)), Pat, true).",
                            [["Pat = goal"]]);