don't expose lexical error and provide location

diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index 18f2335d5d37c59d078063feacdb146dcf4d3e21..f9aa94f916f8e81b55b7fdaaa70b941e5014a579 100644 (file)
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -461,7 +461,7 @@ pub enum ParserErrorKind {
     IncompleteReduction,
     InfiniteFloat,
     InvalidSingleQuotedCharacter(char),
-    LexicalError(lexical::Error),
+    ParseFloat,
     MissingQuote,
     NonPrologChar,
     ParseBigInt,
@@ -492,7 +492,7 @@ impl ParserError {
                 atom!("invalid_data")
             }
             ParserErrorKind::IO(_) => atom!("input_output_error"),
-            ParserErrorKind::LexicalError(_) => atom!("lexical_error"),
+            ParserErrorKind::ParseFloat => atom!("parse_float"),
             ParserErrorKind::MissingQuote => atom!("missing_quote"),
             ParserErrorKind::NonPrologChar => atom!("non_prolog_character"),
             ParserErrorKind::ParseBigInt => atom!("cannot_parse_big_int"),
@@ -519,15 +519,6 @@ impl ParserError {
     }
 }
 
-impl From<lexical::Error> for ParserError {
-    fn from(e: lexical::Error) -> ParserError {
-        ParserError {
-            location: None,
-            kind: ParserErrorKind::LexicalError(e),
-        }
-    }
-}
-
 impl From<IOError> for ParserError {
     fn from(e: IOError) -> ParserError {
         ParserError {

diff --git a/src/parser/lexer.rs b/src/parser/lexer.rs
index 0d3f8941c0a8a48994c867409d3a12e7676ef0b1..e617c7d9592872880576709048777dcda5341007 100644 (file)
--- a/src/parser/lexer.rs
+++ b/src/parser/lexer.rs
@@ -684,7 +684,7 @@ impl<'a, R: CharRead> Lexer<'a, R> {
     ) -> Result<(F64Offset, OrderedFloat<f64>), ParserError> {
         self.return_char(token.pop().unwrap());
 
-        let n = parse_float_lossy(&token)?;
+        let n = self.parse_float_lossy(&token)?;
         let offset = float_alloc!(n, self.machine_st.arena);
 
         Ok((offset, OrderedFloat(n)))
@@ -821,7 +821,7 @@ impl<'a, R: CharRead> Lexer<'a, R> {
                             }
                         }
 
-                        let n = parse_float_lossy(&token)?;
+                        let n = self.parse_float_lossy(&token)?;
                         let offset = float_alloc!(n, self.machine_st.arena);
 
                         Ok(NumberToken::Float(offset, OrderedFloat(n)))
@@ -830,7 +830,7 @@ impl<'a, R: CharRead> Lexer<'a, R> {
                             .map(|(offset, fl)| NumberToken::Float(offset, fl))
                     }
                 } else {
-                    let n = parse_float_lossy(&token)?;
+                    let n = self.parse_float_lossy(&token)?;
                     let offset = float_alloc!(n, self.machine_st.arena);
                     Ok(NumberToken::Float(offset, OrderedFloat(n)))
                 }
@@ -969,7 +969,7 @@ impl<'a, R: CharRead> Lexer<'a, R> {
             Ok(NumberToken::Partial(token_string)) => match self.parse_integer(&token_string) {
                 Ok(n) => Ok(Token::Literal(n.to_literal())),
                 Err(_) => {
-                    let n = parse_float_lossy(&token_string)?;
+                    let n = self.parse_float_lossy(&token_string)?;
                     let offset = float_alloc!(n, self.machine_st.arena);
                     Ok(Token::Literal(Literal::F64(offset, OrderedFloat(n))))
                 }
@@ -1083,14 +1083,17 @@ impl<'a, R: CharRead> Lexer<'a, R> {
             Err(e) => Err(e),
         }
     }
-}
 
-fn parse_float_lossy(token: &str) -> Result<f64, ParserError> {
-    const FORMAT: u128 = lexical::format::STANDARD;
-    let options = lexical::ParseFloatOptions::builder()
-        .lossy(true)
-        .build()
-        .unwrap();
-    let n = lexical::parse_with_options::<f64, _, FORMAT>(token.as_bytes(), &options)?;
-    Ok(n)
+    fn parse_float_lossy(&self, token: &str) -> Result<f64, ParserError> {
+        const FORMAT: u128 = lexical::format::STANDARD;
+        let Ok(options) = lexical::ParseFloatOptions::builder().lossy(true).build() else {
+            return Err(self.located_error(ParserErrorKind::ParseFloat));
+        };
+
+        let Ok(n) = lexical::parse_with_options::<f64, _, FORMAT>(token.as_bytes(), &options)
+        else {
+            return Err(self.located_error(ParserErrorKind::ParseFloat));
+        };
+        Ok(n)
+    }
 }