add slightly more descriptive syntax errors

src/prolog/machine/machine_errors.rs

@@ -58,9 +58,58 @@ impl MachineError {
         MachineError { stub, from: ErrorProvenance::Constructed }
     }
 
-    pub(super) fn syntax_error(error: SyntaxError) -> Self {
+    pub(super) fn syntax_error(h: usize, err: ParserError) -> Self {
-        let stub = functor!("syntax_error", 1, [heap_atom!(error.as_str())]);
+        let err = match err {
-        MachineError { stub, from: ErrorProvenance::Received }
+            ParserError::Arithmetic(_) =>
+                vec![heap_atom!("arithmetic_error")],
+            ParserError::BackQuotedString =>
+                vec![heap_atom!("back_quoted_string")],
+            ParserError::UnexpectedChar(c) =>
+                functor!("unexpected_char", 1, [heap_char!(c)]),
+            ParserError::UnexpectedEOF =>
+                vec![heap_atom!("unexpected_end_of_file")],
+            ParserError::ExpectedRel =>
+                vec![heap_atom!("expected_relation")],
+            ParserError::InadmissibleFact =>                
+                vec![heap_atom!("inadmissible_fact")],
+            ParserError::InadmissibleQueryTerm =>                
+                vec![heap_atom!("inadmissible_query_term")],
+            ParserError::IncompleteReduction =>
+                vec![heap_atom!("incomplete_reduction")],
+            ParserError::InconsistentEntry =>
+                vec![heap_atom!("inconsistent_entry")],
+            ParserError::InvalidModuleDecl =>
+                vec![heap_atom!("invalid_module_declaration")],
+            ParserError::InvalidModuleExport =>
+                vec![heap_atom!("invalid_module_export")],
+            ParserError::InvalidModuleResolution =>
+                vec![heap_atom!("invalid_module_resolution")],
+            ParserError::InvalidRuleHead =>
+                vec![heap_atom!("invalid_head_of_rule")],
+            ParserError::InvalidUseModuleDecl =>
+                vec![heap_atom!("invalid_use_module_declaration")],
+            ParserError::IO(_) =>
+                vec![heap_atom!("input_output_error")],
+            ParserError::MissingQuote =>
+                vec![heap_atom!("missing_quote")],
+            ParserError::NonPrologChar =>
+                vec![heap_atom!("non_prolog_character")],
+            ParserError::ParseBigInt =>
+                vec![heap_atom!("cannot_parse_big_int")],
+            ParserError::ParseFloat =>
+                vec![heap_atom!("cannot_parse_float")],
+            ParserError::Utf8Conversion(_) =>
+                vec![heap_atom!("utf8_conversion_error")]
+        };
+
+        let mut stub = if err.len() == 1 {
+            functor!("syntax_error", 1)            
+        } else {
+            functor!("syntax_error", 1, [heap_str!(h + 2)])
+        };
+        
+        stub.extend(err.into_iter());
+        MachineError { stub, from: ErrorProvenance::Constructed }
     }
 
     pub(super) fn domain_error(error: DomainError, culprit: Addr) -> Self {
@@ -140,19 +189,6 @@ impl ValidType {
     }
 }
 
-#[derive(Clone, Copy)]
-pub enum SyntaxError {
-    ImpDepAtom
-}
-
-impl SyntaxError {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            &SyntaxError::ImpDepAtom => "imp_dep_atom"
-        }
-    }
-}
-
 #[derive(Clone, Copy)]
 pub enum DomainError {
     NotLessThanZero

src/prolog/machine/machine_state.rs

@@ -601,10 +601,10 @@ pub(crate) trait CallPolicy: Any {
                         let addr = reader.machine_st[temp_v!(1)].clone();
                         reader.machine_st.unify(addr, Addr::HeapCell(offset));
                     },
-                    Err(_) => {
+                    Err(e) => {
-                        // 8.14.1.3 k)-l)
+                        let h    = reader.machine_st.heap.h;
                         let stub = MachineError::functor_stub(clause_name!("read"), 1);
-                        let err  = MachineError::syntax_error(SyntaxError::ImpDepAtom);
+                        let err  = MachineError::syntax_error(h, e);
                         let err  = reader.machine_st.error_form(err, stub);
                         
                         return Err(err);

src/prolog/macros.rs

@@ -46,6 +46,12 @@ macro_rules! heap_integer {
     )
 }
 
+macro_rules! heap_char {
+    ($c:expr) => (
+        HeapCellValue::Addr(Addr::Con(Constant::Char($c)))
+    )
+}
+
 macro_rules! heap_atom {
     ($name:expr) => (
         HeapCellValue::Addr(Addr::Con(atom!($name)))
@@ -59,12 +65,15 @@ macro_rules! functor {
     ($name:expr) => (
         vec![ heap_atom!($name) ]
     );
+    ($name:expr, $len:expr) => (
+        vec![ HeapCellValue::NamedStr($len, clause_name!($name), None) ]
+    );
     ($name:expr, $len:expr, [$($args:expr),*]) => (
         vec![ HeapCellValue::NamedStr($len, clause_name!($name), None), $($args),* ]
     );
     ($name:expr, $len:expr, [$($args:expr),*], $fix: expr) => (
         vec![ HeapCellValue::NamedStr($len, clause_name!($name), Some($fix)), $($args),* ]
-    )
+    );    
 }
 
 macro_rules! temp_v {