From bb3c8d1455f7a102a0c0abffd757ccace94f77d5 Mon Sep 17 00:00:00 2001
From: Greg Brown <gmb60@cam.ac.uk>
Date: Tue, 20 Apr 2021 13:22:49 +0100
Subject: Add LALRPOP arithmetic parser.

---
 chomp-bench/src/arith/lalr.lalrpop | 33 +++++++++++++++++++++++++++++++++
 chomp-bench/src/arith/mod.rs       | 24 ++++++++++++++++++++----
 2 files changed, 53 insertions(+), 4 deletions(-)
 create mode 100644 chomp-bench/src/arith/lalr.lalrpop

(limited to 'chomp-bench/src')

diff --git a/chomp-bench/src/arith/lalr.lalrpop b/chomp-bench/src/arith/lalr.lalrpop
new file mode 100644
index 0000000..fe21d01
--- /dev/null
+++ b/chomp-bench/src/arith/lalr.lalrpop
@@ -0,0 +1,33 @@
+use std::str::FromStr;
+
+grammar;
+
+pub Expression: i64 = {
+    <p : Product> <v : (<AddOp> <Product>)*> => {
+        v.into_iter().fold(p, |acc, (op, p)| if op { acc + p } else { acc - p })
+    }
+}
+
+AddOp: bool = {
+    "+" => true,
+    "-" => false,
+}
+
+Product: i64 = {
+    <t : Term> <v : (<MulOp> <Term>)*> => {
+        v.into_iter().fold(t, |acc, (op, t)| if op { acc * t } else { acc / t })
+    }
+}
+
+MulOp: bool = {
+    "*" => true,
+    "/" => false,
+}
+
+Term: i64 = {
+    Number,
+    "-" <Number> => -<>,
+    "(" <Expression> ")",
+}
+
+Number: i64 = r"[0-9]+" => i64::from_str(<>).unwrap();
diff --git a/chomp-bench/src/arith/mod.rs b/chomp-bench/src/arith/mod.rs
index 37432d5..38556fe 100644
--- a/chomp-bench/src/arith/mod.rs
+++ b/chomp-bench/src/arith/mod.rs
@@ -1,39 +1,51 @@
 use chewed::{ParseError, TakeError};
+use lalrpop_util::lalrpop_mod;
 
 pub mod nibble;
+lalrpop_mod!(pub lalr, "/arith/lalr.rs");
 
 pub fn take_number<P: chewed::Parser + ?Sized>(input: &mut P) -> Result<i64, TakeError> {
     let mut out = None;
     loop {
-        match input.next() {
+        match input.peek() {
             Some('0') => {
+                input.consume_str("0")?;
                 out = Some(out.unwrap_or_default() * 10);
             }
             Some('1') => {
+                input.consume_str("1")?;
                 out = Some(out.unwrap_or_default() * 10 + 1);
             }
             Some('2') => {
+                input.consume_str("2")?;
                 out = Some(out.unwrap_or_default() * 10 + 2);
             }
             Some('3') => {
+                input.consume_str("3")?;
                 out = Some(out.unwrap_or_default() * 10 + 3);
             }
             Some('4') => {
+                input.consume_str("4")?;
                 out = Some(out.unwrap_or_default() * 10 + 4);
             }
             Some('5') => {
+                input.consume_str("5")?;
                 out = Some(out.unwrap_or_default() * 10 + 5);
             }
             Some('6') => {
+                input.consume_str("6")?;
                 out = Some(out.unwrap_or_default() * 10 + 6);
             }
             Some('7') => {
+                input.consume_str("7")?;
                 out = Some(out.unwrap_or_default() * 10 + 7);
             }
             Some('8') => {
+                input.consume_str("8")?;
                 out = Some(out.unwrap_or_default() * 10 + 8);
             }
             Some('9') => {
+                input.consume_str("9")?;
                 out = Some(out.unwrap_or_default() * 10 + 9);
             }
             Some(c) => {
@@ -80,13 +92,15 @@ pub fn take_product<P: chewed::Parser + ?Sized>(input: &mut P) -> Result<i64, Ta
     let mut out = take_term(input)?;
     while let Some(c) = input.peek() {
         if c == '*' {
+            input.consume_str("*")?;
             input.skip_while(|c| c == ' ');
             out *= take_term(input)?;
         } else if c == '/' {
+            input.consume_str("/")?;
             input.skip_while(|c| c == ' ');
-            out -= take_term(input)?;
+            out /= take_term(input)?;
         } else {
-            return Err(TakeError::BadBranch(input.pos(), c, &['*', '/']));
+            break
         }
     }
     Ok(out)
@@ -96,13 +110,15 @@ pub fn take_expr<P: chewed::Parser + ?Sized>(input: &mut P) -> Result<i64, TakeE
     let mut out = take_product(input)?;
     while let Some(c) = input.peek() {
         if c == '+' {
+            input.consume_str("+")?;
             input.skip_while(|c| c == ' ');
             out += take_product(input)?;
         } else if c == '-' {
+            input.consume_str("-")?;
             input.skip_while(|c| c == ' ');
             out -= take_product(input)?;
         } else {
-            return Err(TakeError::BadBranch(input.pos(), c, &['+', '-']));
+            break
         }
     }
     Ok(out)
-- 
cgit v1.2.3