add support for quoted atoms to writeq

src/prolog/ast.rs

@@ -795,7 +795,7 @@ pub enum BuiltInClauseType {
     Compare,
     CompareTerm(CompareTermQT),
     CyclicTerm,
-    Display,
+    Writeq,
     DuplicateTerm,
     Eq,
     Functor,
@@ -898,7 +898,7 @@ impl BuiltInClauseType {
             &BuiltInClauseType::Compare => clause_name!("compare"),
             &BuiltInClauseType::CompareTerm(qt) => clause_name!(qt.name()),
             &BuiltInClauseType::CyclicTerm => clause_name!("cyclic_term"),
-            &BuiltInClauseType::Display => clause_name!("display"),
+            &BuiltInClauseType::Writeq => clause_name!("writeq"),
             &BuiltInClauseType::DuplicateTerm => clause_name!("duplicate_term"),
             &BuiltInClauseType::Eq => clause_name!("=="),
             &BuiltInClauseType::Functor => clause_name!("functor"),
@@ -917,7 +917,7 @@ impl BuiltInClauseType {
             &BuiltInClauseType::Compare => 2,
             &BuiltInClauseType::CompareTerm(_) => 2,
             &BuiltInClauseType::CyclicTerm => 1,
-            &BuiltInClauseType::Display => 1,
+            &BuiltInClauseType::Writeq => 1,
             &BuiltInClauseType::DuplicateTerm => 2,
             &BuiltInClauseType::Eq => 2,
             &BuiltInClauseType::Functor => 3,
@@ -941,7 +941,7 @@ impl BuiltInClauseType {
             ("@=<", 2) => Some(BuiltInClauseType::CompareTerm(CompareTermQT::LessThanOrEqual)),
             ("\\=@=", 2) => Some(BuiltInClauseType::CompareTerm(CompareTermQT::NotEqual)),
             ("=@=", 2) => Some(BuiltInClauseType::CompareTerm(CompareTermQT::Equal)),
-            ("display", 1) => Some(BuiltInClauseType::Display),
+            ("writeq", 1) => Some(BuiltInClauseType::Writeq),
             ("duplicate_term", 2) => Some(BuiltInClauseType::DuplicateTerm),
             ("==", 2) => Some(BuiltInClauseType::Eq),
             ("functor", 3) => Some(BuiltInClauseType::Functor),

src/prolog/io.rs

@@ -1,6 +1,7 @@
 use prolog::ast::*;
 use prolog::heap_print::*;
 use prolog::machine::*;
+use prolog::ordered_float::OrderedFloat;
 
 use termion::raw::IntoRawMode;
 use termion::input::TermRead;
@@ -24,17 +25,30 @@ impl fmt::Display for IndexPtr {
 
 impl fmt::Display for Constant {
     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() + "'")
+                }
+            }
+        }
+
         match self {
             &Constant::Atom(ref atom) =>
-                if atom.as_str().chars().any(|c| ".$'\" ".contains(c)) {
-                    write!(f, "'{}'", atom.as_str())
-                } else {
-                    write!(f, "{}", atom.as_str())
-                },
+                print_atom(f, atom),
             &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) =>

src/prolog/machine/machine_state.rs

@@ -492,7 +492,7 @@ pub(crate) trait CallPolicy: Any {
                 machine_st.fail = !machine_st.is_cyclic_term(addr);
                 return_from_clause!(machine_st.last_call, machine_st)
             },
-            &BuiltInClauseType::Display => {
+            &BuiltInClauseType::Writeq => {
                 let output = machine_st.print_term(machine_st[temp_v!(1)].clone(),
                                                    DisplayFormatter {},
                                                    PrinterOutputter::new());

src/prolog/mod.rs

@@ -19,10 +19,10 @@ 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 targets;
 pub mod tabled_rc;