switched to lrpar parser generator

src/tests/expressions.rs

@@ -13,4 +13,4 @@
 //     assert!(IdentParser::new().parse("0").is_err());
 //     assert!(IdentParser::new().parse("0123456").is_err());
 //     assert!(IdentParser::new().parse("0aaaa").is_err());
-// }
+// }

src/tests/literals.rs

@@ -1,80 +1,54 @@
-use crate::ast::literal::Literal;
-use crate::expressions::AtomParser as Parser;
+use lrlex::lrlex_mod;
+use lrpar::lrpar_mod;
 
-#[test]
-fn int_literals() {
-    let parser = Parser::new();
-    let valid_ints = vec!["1234567890", "(1234567890)", "((((1))))"];
-    let invalid_ints = vec!["01", "(1", "6543)", "((987652345)"];
+use crate::ast::{Expression, Literal};
 
-    assert!(valid_ints.into_iter().all(|s| parser.parse(s).is_ok()));
-    assert!(invalid_ints.into_iter().all(|s| parser.parse(s).is_err()));
+lrlex_mod!("grammar.l");
+lrpar_mod!("grammar.y");
+
+macro_rules! test_literal_list {
+
+
+    ($f:ident, $string:literal) => {
+        assert!($f($string))
+    };
+
+    ($f:ident, $first:literal, $($rest:literal),*) => {
+        test_literal_list!($f, $first);
+        test_literal_list!($f, $($rest),*);
+    };
 }
 
-#[test]
-fn test_float_dots() {
-    let valid_floats = vec![
-        "0.0",
-        "-0.0",
-        "3.141592653589793",
-        "-1.123456765432123456789",
-    ];
-    assert!(Parser::new().parse("1.1").is_ok());
-    assert!(Parser::new().parse("-1.1").is_ok());
-    assert!(Parser::new().parse(".1").is_ok());
-    assert!(Parser::new().parse("-.1").is_ok());
+fn parse_str(input: &str) -> Result<Expression, ()> {
+    let lexerdef = grammar_l::lexerdef();
+    let lexer = lexerdef.lexer(&input);
+    let (res, errs) = grammar_y::parse(&lexer);
+    if let Some(parsed_res) = res {
+        parsed_res
+    } else {
+        Err(())
+    }
 }
-
 #[test]
-fn test_float_exps() {
-    let parser = crate::expressions::FloatParser::new();
 
-    let valid_float_exps: Vec<&str> = vec![
-        "1e1", "-1e1", "1e-1", "-1e-1", "1.1e1", "1.1e-1", "-1.1e1", "-1.1e-1", ".1e1", "-.1e1",
-        "-.1e-1", "1E1", "-1E1", "1E-1", "-1E-1", "1.1E1", "1.1E-1", "-1.1E1", "-1.1E-1", ".1E1",
-        "-.1E1", "-.1E-1",
-    ];
+fn test_int_literal() {
+    let lexer = grammar_l::lexerdef();
+    let valid_ints = vec!["1", "1", "100000000000000000", "1234567890", "1234567890"];
+    let invalid_ints = vec!["01", "AAAAAAAAAAAAAAA", "-1"];
 
-    let invalid_float_exps: Vec<&str> = vec![
-        "AAAAAAAAAAAAAAA",
-        "1.e1",
-        "1e1.1",
-        "1.1e1.1",
-        "-1e1.1",
-        "1e-1.1",
-    ];
+    let matches_parsed_int = |s: &str| match parse_str(s) {
+        Ok(i) => matches!(i, Expression::Lit(Literal::Int(_))),
+        Err(_) => false,
+    };
 
-    assert!(
-        valid_float_exps
-            .into_iter()
-            .all(|s| parser.parse(s).is_ok())
-    );
-    assert!(
-        invalid_float_exps
-            .into_iter()
-            .all(|s| parser.parse(s).is_err())
+    test_literal_list!(
+        matches_parsed_int,
+        "1",
+        "1",
+        "100000000000000000",
+        "1234567890",
+        "1234567890"
     );
-}
-
-#[test]
-fn test_atom_parser() {
-    use crate::ast::literal::Literal;
-    let parser = crate::expressions::AtomParser::new();
-
-    let parsed_int_atom = parser.parse("123");
-    assert!(matches!(parsed_int_atom, Ok(Literal::Int(_))));
-
-    let parsed_int_atom = parser.parse("-1.12345");
-    assert!(matches!(parsed_int_atom, Ok(Literal::Float(_))));
-}
-
-#[test]
-fn test_expr_parser() {
-    let parser = crate::expressions::ASTExpressionParser::new();
-
-    let parsed_int_expr = parser.parse("123");
-    assert!(matches!(parsed_int_expr, Ok(Literal::Int(_))));
-
-    let parsed_int_expr = parser.parse("-4.20E-69");
-    assert!(matches!(parsed_int_expr, Ok(Literal::Float(_))));
+
+    // test_literal_list!(parse_str, "01", "AAAAAAAAAAAAAAA", "-1");
 }

src/tests/mod.rs

@@ -1,2 +1,2 @@
-mod literals;
 mod expressions;
+mod literals;