remove double_quotes checks from unnecessary places in system_calls.rs and elsewhere...

diff --git a/src/prolog/heap_iter.rs b/src/prolog/heap_iter.rs
index 28cdaf85ae31c7524c1fd7c304ca5f5b723f4cce..c478f5474806a7c593c17e136d0e1193112dbc5a 100644 (file)
--- a/src/prolog/heap_iter.rs
+++ b/src/prolog/heap_iter.rs
@@ -93,21 +93,19 @@ impl<'a> HCPreOrderIterator<'a> {
             }
             Addr::Con(h) => {
                 if let &HeapCellValue::PartialString(ref pstr, has_tail) = &self.machine_st.heap[h] {
-                    if !self.machine_st.flags.double_quotes.is_atom() {
-                        return if let Some(c) = pstr.range_from(0 ..).next() {
-                            self.state_stack.push(Addr::PStrLocation(h, c.len_utf8()));
-                            self.state_stack.push(Addr::Char(c));
+                    if let Some(c) = pstr.range_from(0 ..).next() {
+                        self.state_stack.push(Addr::PStrLocation(h, c.len_utf8()));
+                        self.state_stack.push(Addr::Char(c));
 
-                            Addr::PStrLocation(h, 0)
-                        } else if has_tail {
-                            self.follow(Addr::HeapCell(h + 1))
-                        } else {
-                            Addr::EmptyList
-                        };
+                        Addr::PStrLocation(h, 0)
+                    } else if has_tail {
+                        self.follow(Addr::HeapCell(h + 1))
+                    } else {
+                        Addr::EmptyList
                     }
+                } else {
+                    Addr::Con(h)
                 }
-
-                Addr::Con(h)
             }
             da => {
                 da

diff --git a/src/prolog/heap_print.rs b/src/prolog/heap_print.rs
index ca462e02012f7a5501f5d4ed7e6f4fcb1b4494aa..d798ea68f39ceaac448c40c5059a47f30af6d974 100644 (file)
--- a/src/prolog/heap_print.rs
+++ b/src/prolog/heap_print.rs
@@ -1173,7 +1173,7 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
         let at_cdr = self.at_cdr(",");
 
         if !at_cdr && Addr::EmptyList == end_addr {
-            if self.machine_st.flags.double_quotes.is_chars() && !self.ignore_ops {
+            if !self.ignore_ops {
                 self.print_proper_string(buf, max_depth);
                 return;
             }
@@ -1190,18 +1190,6 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
 
         let mut byte_len = 0;
 
-        let char_printer = |printer: &mut Self, c| {
-            if printer.machine_st.flags.double_quotes.is_codes() {
-                let s = (c as u32).to_string();
-
-                push_space_if_amb!(printer, &s, {
-                    printer.append_str(&s);
-                });
-            } else {
-                printer.print_char(printer.quoted, c);
-            }
-        };
-
         if self.ignore_ops {
             let mut char_count = 0;
 
@@ -1209,7 +1197,7 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
                 self.append_str("'.'");
                 self.push_char('(');
 
-                char_printer(self, c);
+                self.print_char(self.quoted, c);
                 self.push_char(',');
 
                 char_count += 1;
@@ -1235,7 +1223,7 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
             };
 
             for c in buf_iter {
-                char_printer(self, c);
+                self.print_char(self.quoted, c);
                 self.push_char(',');
 
                 byte_len += c.len_utf8();

diff --git a/src/prolog/machine/machine_state_impl.rs b/src/prolog/machine/machine_state_impl.rs
index 1e52dd1bec7487aa947dfb8d08e8917351cbc067..494df6a46cb91268770480637eedbde61842ee55 100644 (file)
--- a/src/prolog/machine/machine_state_impl.rs
+++ b/src/prolog/machine/machine_state_impl.rs
@@ -818,7 +818,7 @@ impl MachineState {
 
                         self.bind(addr.as_var().unwrap(), pstr_addr);
                     }
-                    Addr::Lis(l) if !self.flags.double_quotes.is_atom() => {
+                    Addr::Lis(l) => {
                         let h = self.heap.h();
 
                         let pstr_addr =
@@ -920,7 +920,7 @@ impl MachineState {
                     self.fail = true;
                 }
             }
-            Addr::Lis(l) if !self.flags.double_quotes.is_atom() => {
+            Addr::Lis(l) => {
                 let addr = self.heap.put_constant(c.clone());
                 self.unify(Addr::Lis(l), addr);
             }
@@ -1404,11 +1404,7 @@ impl MachineState {
                         v
                     }
                     Addr::PStrLocation(..) => {
-                        if !self.flags.double_quotes.is_atom() {
-                            l
-                        } else {
-                            c
-                        }
+                        l
                     }
                     Addr::Char(_) | Addr::Con(_) | Addr::CutPoint(_) |
                     Addr::EmptyList | Addr::Fixnum(_) | Addr::Float(_) | Addr::Usize(_) => {
@@ -1884,11 +1880,10 @@ impl MachineState {
                         unreachable!()
                     }
                 }
-                (Addr::PStrLocation(..), Addr::Lis(_))
-              | (Addr::Lis(_), Addr::PStrLocation(..))
-                    if !self.flags.double_quotes.is_atom() => {
-                        continue;
-                    }
+                (Addr::PStrLocation(..), Addr::Lis(_)) |
+                (Addr::Lis(_), Addr::PStrLocation(..)) => {
+                    continue;
+                }
                 (pstr1 @ Addr::PStrLocation(..), pstr2 @ Addr::PStrLocation(..)) => {
                     let mut i1 = self.heap_pstr_iter(pstr1);
                     let mut i2 = self.heap_pstr_iter(pstr2);
@@ -2248,7 +2243,7 @@ impl MachineState {
                         (
                             Addr::PStrLocation(..),
                             Addr::Lis(_),
-                        ) if !self.flags.double_quotes.is_atom() => {
+                        ) => {
                         }
                         (
                             Addr::Lis(_),
@@ -2277,7 +2272,7 @@ impl MachineState {
                         (
                             Addr::PStrLocation(..),
                             Addr::Str(s),
-                        ) if !self.flags.double_quotes.is_atom() => {
+                        ) => {
                             if let &HeapCellValue::NamedStr(a1, ref n1, _) = &self.heap[s] {
                                 if a1 != 2 || n1.as_str() != "." {
                                     return Some(a1.cmp(&2).then_with(|| n1.as_str().cmp(".")));
@@ -2289,7 +2284,7 @@ impl MachineState {
                         (
                             Addr::Str(s),
                             Addr::PStrLocation(..),
-                        ) if !self.flags.double_quotes.is_atom() => {
+                        ) => {
                             if let &HeapCellValue::NamedStr(a1, ref n1, _) = &self.heap[s] {
                                 if a1 != 2 || n1.as_str() != "." {
                                     return Some(2.cmp(&a1).then_with(|| ".".cmp(n1.as_str())));
@@ -2375,14 +2370,7 @@ impl MachineState {
                         }
                     }
                     _ => {
-                        match d {
-                            Addr::Char(_) if self.flags.double_quotes.is_codes() => {
-                                self.p += 1;
-                            }
-                            _ => {
-                                self.fail = true;
-                            }
-                        }
+                        self.fail = true;
                     }
                 }
             }
@@ -2888,7 +2876,7 @@ impl MachineState {
                 | (
                     HeapCellValue::Addr(Addr::PStrLocation(..)),
                     HeapCellValue::Addr(Addr::Lis(_)),
-                ) if !self.flags.double_quotes.is_atom() => {
+                ) => {
                 }
                 (
                     HeapCellValue::NamedStr(ar1, n1, _),

diff --git a/src/prolog/machine/system_calls.rs b/src/prolog/machine/system_calls.rs
index dcc15bc1d8c890e19ad8d0db89385bc92ecfe50c..d731e4254af3a370761aae5da5866a8e6ab52b56 100644 (file)
--- a/src/prolog/machine/system_calls.rs
+++ b/src/prolog/machine/system_calls.rs
@@ -185,20 +185,14 @@ impl MachineState {
             }
             Addr::Con(h) if max_steps > 0 => {
                 if let HeapCellValue::PartialString(..) = &self.heap[h] {
-                    if !self.flags.double_quotes.is_atom() {
-                        Addr::PStrLocation(h, 0)
-                    } else {
-                        return CycleSearchResult::NotList;
-                    }
+                    Addr::PStrLocation(h, 0)
                 } else {
                     return CycleSearchResult::NotList;
                 }
             }
             Addr::Con(h) => {
                 if let HeapCellValue::PartialString(..) = &self.heap[h] {
-                    if !self.flags.double_quotes.is_atom() {
-                        return CycleSearchResult::UntouchedList(h);
-                    }
+                    return CycleSearchResult::UntouchedList(h);
                 }
 
                 return CycleSearchResult::NotList;
@@ -236,11 +230,7 @@ impl MachineState {
             }
             Addr::Con(h) => {
                 if let HeapCellValue::PartialString(..) = &self.heap[h] {
-                    if !self.flags.double_quotes.is_atom() {
-                        Addr::PStrLocation(h, 0)
-                    } else {
-                        return CycleSearchResult::NotList;
-                    }
+                    Addr::PStrLocation(h, 0)
                 } else {
                     return CycleSearchResult::NotList;
                 }
@@ -846,10 +836,9 @@ impl MachineState {
                             let a2 = self[temp_v!(2)];
 
                             match self.store(self.deref(a2)) {
-                                Addr::PStrLocation(..)
-                                    if !self.flags.double_quotes.is_chars() => {
-                                        self.fail = true;
-                                    }
+                                Addr::PStrLocation(..) => {
+                                    self.fail = true;
+                                }
                                 a2 => {
                                     self.unify(a2, list_of_chars);
                                 }
@@ -918,35 +907,17 @@ impl MachineState {
                         self.unify(a2, list_of_codes);
                     }
                     Addr::Con(h) if self.heap.atom_at(h) => {
-                       if let HeapCellValue::Atom(name, _) = self.heap.clone(h) {
-                            let a2 = self[temp_v!(2)];
+                           if let HeapCellValue::Atom(name, _) = self.heap.clone(h) {
+                            let a2 = self.store(self.deref(self[temp_v!(2)]));
 
-                            match self.store(self.deref(a2)) {
-                                a2 @ Addr::PStrLocation(..) => {
-                                    if !self.flags.double_quotes.is_codes() {
-                                        self.fail = true;
-                                    } else {
-                                        let iter = name
-                                            .as_str()
-                                            .chars()
-                                            .map(|c| Addr::Char(c));
+                            let iter = name
+                                .as_str()
+                                .chars()
+                                .map(|c| Addr::Fixnum(c as isize));
 
-                                        let list_of_codes = Addr::HeapCell(self.heap.to_list(iter));
+                            let list_of_codes = Addr::HeapCell(self.heap.to_list(iter));
 
-                                        self.unify(a2, list_of_codes);
-                                    }
-                                }
-                                a2 => {
-                                    let iter = name
-                                        .as_str()
-                                        .chars()
-                                        .map(|c| Addr::Fixnum(c as isize));
-
-                                    let list_of_codes = Addr::HeapCell(self.heap.to_list(iter));
-
-                                    self.unify(a2, list_of_codes);
-                                }
-                            }
+                            self.unify(a2, list_of_codes);
                         } else {
                             unreachable!()
                         }