use heap_pstr_iter in AtomChars (#482)

diff --git a/src/prolog/lib/builtins.pl b/src/prolog/lib/builtins.pl
index 798e201a8b1a61f82429f68d493455599184926d..0cf39457300b94ea510a9ae327dce5e041eb4cbf 100644 (file)
--- a/src/prolog/lib/builtins.pl
+++ b/src/prolog/lib/builtins.pl
@@ -932,7 +932,7 @@ atom_chars(Atom, List) :-
     ),
     (  var(Atom) ->
        (  var(Tail) -> throw(error(instantiation_error, atom_chars/2))
-       ;  ground(List), Tail == [] -> '$atom_chars'(Atom, List)
+       ;  ground(List) -> '$atom_chars'(Atom, List)
        ;  throw(error(instantiation_error, atom_chars/2))
        )
     ;  atom(Atom) -> can_be_chars_or_vars(List, atom_chars/2), '$atom_chars'(Atom, List)

diff --git a/src/prolog/machine/system_calls.rs b/src/prolog/machine/system_calls.rs
index b1abfdd2dc6c36476ba9bafc63a8e90e37f3998e..025997169c0dbb20074a12964ea7368c73083141 100644 (file)
--- a/src/prolog/machine/system_calls.rs
+++ b/src/prolog/machine/system_calls.rs
@@ -864,30 +864,34 @@ impl MachineState {
                         self.unify(a2, list_of_chars);
                     }
                     addr if addr.is_ref() => {
-                        let stub = MachineError::functor_stub(clause_name!("atom_chars"), 2);
+                        let mut iter = self.heap_pstr_iter(self[temp_v!(2)]);
+                        let string = iter.to_string();
+
+                        match iter.focus() {
+                            Addr::EmptyList => {
+                                let chars = clause_name!(string, indices.atom_tbl);
+                                let atom  = self.heap.to_unifiable(
+                                    HeapCellValue::Atom(chars, None)
+                                );
 
-                        match self.try_from_list(temp_v!(2), stub) {
-                            Err(e) => {
-                                return Err(e);
+                                self.unify(addr, atom);
                             }
-                            Ok(addrs) => {
-                                match self.try_char_list(addrs) {
-                                    Ok(string) => {
-                                        let chars = clause_name!(string, indices.atom_tbl);
-                                        let atom  = self.heap.to_unifiable(
-                                            HeapCellValue::Atom(chars, None)
-                                        );
-
-                                        self.unify(addr, atom);
-                                    }
-                                    Err(err) => {
-                                        let stub = MachineError::functor_stub(
-                                            clause_name!("atom_chars"),
-                                            2,
-                                        );
+                            focus => {
+                                let stub = MachineError::functor_stub(
+                                    clause_name!("atom_chars"),
+                                    2,
+                                );
 
-                                        return Err(self.error_form(err, stub));
-                                    }
+                                if let Addr::Lis(l) = focus {
+                                    let err = MachineError::type_error(
+                                        self.heap.h(),
+                                        ValidType::Character,
+                                        Addr::HeapCell(l),
+                                    );
+
+                                    return Err(self.error_form(err, stub));
+                                } else {
+                                    unreachable!()
                                 }
                             }
                         }