add support for char codes

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "scryer-prolog"
-version = "0.8.31"
+version = "0.8.32"
 authors = ["Mark Thom <markjordanthom@gmail.com>"]
 repository = "https://github.com/mthom/scryer-prolog"
 description = "A modern Prolog implementation written mostly in Rust."
@@ -14,7 +14,7 @@ cfg-if = "0.1.7"
 downcast = "0.10.0"
 num = "0.2"
 ordered-float = "0.5.0"
-prolog_parser = "0.8.9"
+prolog_parser = "0.8.10"
 readline_rs_compat = { version = "0.1.7", optional = true }
 ref_thread_local = "0.0.0"
 

src/prolog/heap_iter.rs

@@ -48,17 +48,27 @@ impl<'a> HCPreOrderIterator<'a> {
         let da = self.machine_st.store(self.machine_st.deref(addr));
 
         match da {
-            Addr::Con(Constant::String(ref s))
+            Addr::Con(Constant::String(ref s)) => {
-                if self.machine_st.machine_flags().double_quotes.is_chars() => {
+                match self.machine_st.machine_flags().double_quotes {
-                    if let Some(c) = s.head() {
+                    DoubleQuotes::Chars =>
-                        let tail = s.tail();
+                        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::String(tail)));
-                        self.state_stack.push(Addr::Con(Constant::Char(c)));
+                            self.state_stack.push(Addr::Con(Constant::Char(c)));
-                    }
+                        },
+                    DoubleQuotes::Codes =>
+                        if let Some(c) = s.head() {
+                            let tail = s.tail();
 
-                    Addr::Con(Constant::String(s.clone()))
+                            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));

src/prolog/heap_print.rs

@@ -1,4 +1,5 @@
 use prolog_parser::ast::*;
+use prolog_parser::string_list::*;
 
 use prolog::clause_types::*;
 use prolog::heap_iter::*;
@@ -652,37 +653,46 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter>
                 } else {
                     self.print_char(c);
                 },
+            Constant::CharCode(c) =>
+                self.append_str(&format!("{}", c)),            
             Constant::EmptyList =>
                 self.append_str("[]"),
             Constant::Number(n) =>
                 self.print_number(n, op),
             Constant::String(s) =>
-                if self.machine_st.machine_flags().double_quotes.is_chars() {
+                self.print_string(s),
-                    if !s.is_empty() {
-                        if self.ignore_ops {
-                            self.format_struct(2, clause_name!("."));
-                        } else {
-                            self.push_list();
-                        }
-                    } else if s.is_expandable() {
-                        if !self.at_cdr(" | _") {
-                            self.push_char('_');
-                        }
-                    } else if !self.at_cdr("") {
-                        self.append_str("[]");
-                    }
-                } else { // for now, == DoubleQuotes::Atom
-                    let borrowed_str = s.borrow();
-
-                    self.push_char('"');
-                    self.append_str(&borrowed_str[s.cursor() ..]);
-                    self.push_char('"');
-                },
             Constant::Usize(i) =>
                 self.append_str(&format!("u{}", i))
         }
     }
 
+    fn print_string(&mut self, s: StringList) {
+        match self.machine_st.machine_flags().double_quotes {
+            DoubleQuotes::Chars | DoubleQuotes::Codes => {
+                if !s.is_empty() {
+                    if self.ignore_ops {
+                        self.format_struct(2, clause_name!("."));
+                    } else {
+                        self.push_list();
+                    }
+                } else if s.is_expandable() {
+                    if !self.at_cdr(" | _") {
+                        self.push_char('_');
+                    }
+                } else if !self.at_cdr("") {
+                    self.append_str("[]");
+                }
+            },
+            DoubleQuotes::Atom => {
+                let borrowed_str = s.borrow();
+
+                self.push_char('"');
+                self.append_str(&borrowed_str[s.cursor() ..]);
+                self.push_char('"');
+            }
+        }
+    }
+
     fn push_list(&mut self) {
         let cell = Rc::new(Cell::new(true));
 

src/prolog/lib/builtins.pl

@@ -107,7 +107,9 @@ set_prolog_flag(integer_rounding_function, Value) :-
 set_prolog_flag(double_quotes, chars) :-
     !, '$set_double_quotes'(chars). % 7.11.2.5, list of one-char atoms.
 set_prolog_flag(double_quotes, atom) :-
-    !, '$set_double_quotes'(atom). % 7.11.2.5, list of one-char atoms.
+    !, '$set_double_quotes'(atom). % 7.11.2.5, list of char codes (UTF8).
+set_prolog_flag(double_quotes, codes) :-
+    !, '$set_double_quotes'(codes). 
 set_prolog_flag(double_quotes, Value) :-
     throw(error(domain_error(flag_value, double_quotes + Value),
 		set_prolog_flag/2)). % 8.17.1.3 e

src/prolog/machine/machine_state_impl.rs

@@ -196,7 +196,7 @@ impl MachineState {
     }
 
     pub(super)
-    fn unify_string(&mut self, pdl: &mut Vec<Addr>, s1: &mut StringList, s2: &mut StringList) -> bool
+    fn unify_strings(&mut self, pdl: &mut Vec<Addr>, s1: &mut StringList, s2: &mut StringList) -> bool
     {
         if let Some(c1) = s1.head() {
             if let Some(c2) = s2.head() {
@@ -240,6 +240,86 @@ impl MachineState {
         false
     }
 
+    fn deconstruct_chars(&mut self, s: &mut StringList, offset: usize, pdl: &mut Vec<Addr>) -> bool
+    {
+        if let Some(c) = s.head() {
+            pdl.push(Addr::Con(Constant::String(s.tail())));
+            pdl.push(Addr::HeapCell(offset + 1));
+
+            pdl.push(Addr::Con(Constant::Char(c)));
+            pdl.push(Addr::HeapCell(offset));
+
+            return true;
+        } else if s.is_expandable() {
+            let prev_s = s.clone();
+
+            let mut stepper = |c| {
+                let new_s = s.push_char(c);
+
+                pdl.push(Addr::HeapCell(offset + 1));
+                pdl.push(Addr::Con(Constant::String(new_s)));
+            };
+
+            match self.heap[offset].clone() {
+                HeapCellValue::Addr(Addr::Con(Constant::Char(c))) => {
+                    self.pstr_trail(prev_s);
+                    stepper(c);
+                    return true;
+                },
+                HeapCellValue::Addr(Addr::Con(Constant::Atom(ref a, _))) =>
+                    if let Some(c) = a.as_str().chars().next() {
+                        if c.len_utf8() == a.as_str().len() {
+                            self.pstr_trail(prev_s);
+                            stepper(c);
+                            return true;
+                        }
+                    },
+                _ => {}
+            }
+        }
+
+        false
+    }
+
+    fn deconstruct_codes(&mut self, s: &mut StringList, offset: usize, pdl: &mut Vec<Addr>) -> bool
+    {
+        if let Some(c) = s.head() {
+            pdl.push(Addr::Con(Constant::String(s.tail())));
+            pdl.push(Addr::HeapCell(offset + 1));
+
+            pdl.push(Addr::Con(Constant::CharCode(c as u8)));
+            pdl.push(Addr::HeapCell(offset));
+
+            return true;
+        } else if s.is_expandable() {
+            let prev_s = s.clone();
+
+            let mut stepper = |c| {
+                let new_s = s.push_char(c);
+
+                pdl.push(Addr::HeapCell(offset + 1));
+                pdl.push(Addr::Con(Constant::String(new_s)));
+            };
+
+            match self.heap[offset].clone() {
+                HeapCellValue::Addr(Addr::Con(Constant::CharCode(c))) => {
+                    self.pstr_trail(prev_s);
+                    stepper(c as char);
+                    return true;
+                },
+                HeapCellValue::Addr(Addr::Con(Constant::Number(Number::Integer(n)))) =>
+                    if let Some(c) = n.to_u8() {
+                        self.pstr_trail(prev_s);
+                        stepper(c as char);
+                        return true;
+                    },
+                _ => {}
+            }
+        }
+
+        false
+    }
+
     pub(super) fn unify(&mut self, a1: Addr, a2: Addr) {
         let mut pdl = vec![a1, a2];
 
@@ -277,49 +357,20 @@ impl MachineState {
                         self.fail = true;
                     },
                     (Addr::Lis(a1), Addr::Con(Constant::String(ref mut s)))
-                        | (Addr::Con(Constant::String(ref mut s)), Addr::Lis(a1))
+                  | (Addr::Con(Constant::String(ref mut s)), Addr::Lis(a1)) => {
-                        if self.flags.double_quotes.is_chars() => {
+                      if match self.flags.double_quotes {
-                            if let Some(c) = s.head() {
+                          DoubleQuotes::Chars => self.deconstruct_chars(s, a1, &mut pdl),
-                                pdl.push(Addr::Con(Constant::String(s.tail())));
+                          DoubleQuotes::Codes => self.deconstruct_codes(s, a1, &mut pdl),
-                                pdl.push(Addr::HeapCell(a1 + 1));
+                          DoubleQuotes::Atom  => false
+                      } {
+                          continue;
+                      }
 
-                                pdl.push(Addr::Con(Constant::Char(c)));
+                      self.fail = true;
-                                pdl.push(Addr::HeapCell(a1));
+                    },
-
-                                continue;
-                            } else if s.is_expandable() {
-                                let prev_s = s.clone();
-
-                                let mut stepper = |c| {
-                                    let new_s = s.push_char(c);
-
-                                    pdl.push(Addr::HeapCell(a1 + 1));
-                                    pdl.push(Addr::Con(Constant::String(new_s)));
-                                };
-
-                                match self.heap[a1].clone() {
-                                    HeapCellValue::Addr(Addr::Con(Constant::Char(c))) => {
-                                        self.pstr_trail(prev_s);
-                                        stepper(c);
-                                        continue;
-                                    },
-                                    HeapCellValue::Addr(Addr::Con(Constant::Atom(ref a, _))) =>
-                                        if let Some(c) = a.as_str().chars().next() {
-                                            if c.len_utf8() == a.as_str().len() {
-                                                self.pstr_trail(prev_s);
-                                                stepper(c);
-                                                continue;
-                                            }
-                                        },
-                                    _ => {}
-                                };
-                            }
-
-                            self.fail = true;
-                        },
                     (Addr::Con(Constant::EmptyList), Addr::Con(Constant::String(ref s)))
-                        | (Addr::Con(Constant::String(ref s)), Addr::Con(Constant::EmptyList))
+                  | (Addr::Con(Constant::String(ref s)), Addr::Con(Constant::EmptyList))
-                        if self.flags.double_quotes.is_chars() => {
+                        if !self.flags.double_quotes.is_atom() => {
                             if s.is_expandable() && s.is_empty() {
                                 self.pstr_trail(s.clone());
                                 s.set_expandable(false);
@@ -337,8 +388,8 @@ impl MachineState {
                     },
                     (Addr::Con(Constant::String(ref mut s1)),
                      Addr::Con(Constant::String(ref mut s2))) =>
-                        self.fail = !(self.unify_string(&mut pdl, s1, s2)
+                        self.fail = !(self.unify_strings(&mut pdl, s1, s2)
-                                      || self.unify_string(&mut pdl, s2, s1)),
+                                   || self.unify_strings(&mut pdl, s2, s1)),
                     (Addr::Con(ref c1), Addr::Con(ref c2)) =>
                         if c1 != c2 {
                             self.fail = true;
@@ -523,51 +574,81 @@ impl MachineState {
         false
     }
 
-    pub(super) fn write_constant_to_var(&mut self, addr: Addr, c: Constant) {
+    fn write_constant_to_string(&mut self, s: &mut StringList, c: Constant) -> bool {
-        match self.store(self.deref(addr)) {
+        match c {
-            Addr::Con(Constant::String(ref mut s)) =>
+            Constant::EmptyList if !self.flags.double_quotes.is_atom() =>
-                self.fail = match c {
+                !s.is_empty(),
-                    Constant::EmptyList if self.flags.double_quotes.is_chars() =>
+            Constant::String(ref s2)
-                        !s.is_empty(),
+                if s.is_expandable() && s2.starts_with(s) => {
-                    Constant::String(ref s2)
+                    self.pstr_trail(s.clone());
-                        if s.is_expandable() && s2.starts_with(s) => {
+                    s.append_suffix(s2);
-                            self.pstr_trail(s.clone());
+                    s.set_expandable(s2.is_expandable());
-                            s.append_suffix(s2);
+                    false
-                            s.set_expandable(s2.is_expandable());
+                },
-                            false
+            Constant::String(s2) =>
-                        },
+                s.borrow()[s.cursor() ..] != s2.borrow()[s2.cursor() ..],
-                    Constant::String(s2) => *s != s2,
+            Constant::Atom(ref a, _)
-                    Constant::Atom(ref a, _)
+                if a.as_str().starts_with(&s.borrow()[s.cursor() ..]) =>
-                        if a.as_str().starts_with(&s.borrow()[s.cursor() ..]) =>
+                if let Some(c) = a.as_str().chars().next() {
-                            if let Some(c) = a.as_str().chars().next() {
+                    if c.len_utf8() == a.as_str().len() {
-                                if c.len_utf8() == a.as_str().len() {
+                        // detect chars masquerading as atoms.
-                                    // detect chars masquerading as atoms.
+                        if s.is_empty() {
-                                    if s.is_empty() {
+                            self.write_char_to_string(s, c);
-                                        self.write_char_to_string(s, c);
+                        }
-                                    }
 
-                                    false
+                        false
-                                } else {
+                    } else {
-                                    true
+                        true
-                                }
+                    }
-                            } else {
+                } else {
-                                true
+                    true
-                            },
+                },
-                    Constant::Char(ref c) if s.is_empty() && s.is_expandable() =>
+            Constant::Char(ref c) if s.is_empty() && s.is_expandable() =>
-                        self.write_char_to_string(s, *c),
+                match self.flags.double_quotes {
-                    Constant::Char(ref c) =>
+                    DoubleQuotes::Chars => self.write_char_to_string(s, *c),
+                    _ => false
+                },
+            Constant::Char(ref c) =>
+                match self.flags.double_quotes {
+                    DoubleQuotes::Chars =>
                         if s.borrow().chars().next() == Some(*c) && c.len_utf8() == s.len() {
                             s.set_expandable(false);
                             false
                         } else {
                             true
                         },
-                    _ => true
+                    _ => false
                 },
+            Constant::CharCode(ref c) if s.is_empty() && s.is_expandable() =>
+                match self.flags.double_quotes {
+                    DoubleQuotes::Codes => self.write_char_to_string(s, *c as char),
+                    _ => false
+                },
+            Constant::CharCode(ref c) =>
+                match self.flags.double_quotes {
+                    DoubleQuotes::Codes =>
+                        if s.borrow().chars().next() == Some(*c as char) && 1 == s.len() {
+                            s.set_expandable(false);
+                            false
+                        } else {
+                            true
+                        },
+                    _ => false
+                },
+            _ => true
+        }
+    }
+
+    pub(super) fn write_constant_to_var(&mut self, addr: Addr, c: Constant) {
+        match self.store(self.deref(addr)) {
+            Addr::Con(Constant::String(ref mut s)) =>
+                self.fail = self.write_constant_to_string(s, c),
             Addr::Con(c1) =>
                 if c1 != c {
                     self.fail = true;
                 },
+            Addr::Lis(l) =>
+                self.unify(Addr::Lis(l), Addr::Con(c)),
             addr => if let Some(r) = addr.as_var() {
                 self.bind(r, Addr::Con(c));
             } else {
@@ -1207,7 +1288,7 @@ impl MachineState {
 
                 let offset = match addr {
                     Addr::HeapCell(_) | Addr::StackCell(..) | Addr::AttrVar(..) => v,
-                    Addr::Con(Constant::String(_)) if self.flags.double_quotes.is_chars() => l,
+                    Addr::Con(Constant::String(_)) if !self.flags.double_quotes.is_atom() => l,
                     Addr::Con(_) => c,
                     Addr::Lis(_) => l,
                     Addr::Str(_) => s,

src/prolog/machine/system_calls.rs

@@ -736,7 +736,9 @@ impl MachineState {
                     DoubleQuotes::Chars =>
                         self.unify(a1, Addr::Con(atom!("chars"))),
                     DoubleQuotes::Atom =>
-                        self.unify(a1, Addr::Con(atom!("atom")))
+                        self.unify(a1, Addr::Con(atom!("atom"))),
+                    DoubleQuotes::Codes =>
+                        self.unify(a1, Addr::Con(atom!("codes")))
                 }
             },
             &SystemClauseType::GetSCCCleaner => {
@@ -985,6 +987,8 @@ impl MachineState {
                         self.flags.double_quotes = DoubleQuotes::Chars,
                     Addr::Con(Constant::Atom(ref atom, _)) if atom.as_str() == "atom" =>
                         self.flags.double_quotes = DoubleQuotes::Atom,
+                    Addr::Con(Constant::Atom(ref atom, _)) if atom.as_str() == "codes" =>
+                        self.flags.double_quotes = DoubleQuotes::Codes,
                     _ => self.fail = true
                 },
             &SystemClauseType::InferenceLevel => {