Merge pull request #13 from Tsukuba-Programming-Lab/#6_ImplSExp

#6 パース結果をS式で受け取れるようにした

Author: Yuta1004

crates/algorithm_lr1/src/driver.rs

@@ -1,5 +1,6 @@
 use pgen_core::cfg::{TokenSet, Syntax};
 use pgen_core::lex::Token;
+use pgen_core::parse::{SExp, SExpBuilder};
 
 use crate::error::ParseError;
 use crate::builder::{LRAction, LR1Configure};
@@ -21,8 +22,9 @@ where
     pub fn run<'c>(
         &self,
         lexer: &mut impl Iterator<Item = Token<'a, 'c, T>>,
-    ) -> anyhow::Result<()> {
+    ) -> anyhow::Result<SExp<'a, 'c, T, S>> {
         let mut stack = vec![0];
+        let mut builder = SExpBuilder::new();
         loop {
             let input = lexer.next();
             loop {
@@ -38,23 +40,26 @@ where
                     ),
                 };
                 match action {
-                    (LRAction::Shift(new_state), _) => {
+                    (LRAction::Shift(new_state), Some(token)) => {
                         stack.push(*new_state);
+                        builder.push(token);
                         break;
                     }
-                    (LRAction::Reduce(_, goto, elems_cnt), _) => {
+                    (LRAction::Reduce(tag, goto, elems_cnt), _) => {
                         stack.truncate(stack.len() - elems_cnt);
                         stack.push(self.0.goto_table[stack[stack.len() - 1]][*goto]);
+                        builder.wrap(*tag, *elems_cnt);
                     }
                     (LRAction::Accept, _) => {
-                        return Ok(());
+                        return builder.build();
                     }
                     (LRAction::None, Some(token)) => {
                         return Err(ParseError::new_unexpected_token(token).into());
                     }
                     (LRAction::None, None) => {
                         return Err(ParseError::UnexpectedEOF.into());
                     }
+                    _ => unreachable!(),
                 }
             }
         }

crates/algorithm_lr1/src/lib.rs

@@ -6,7 +6,7 @@ use serde::{Serialize, Deserialize};
 
 use pgen_core::cfg::{TokenSet, Syntax};
 use pgen_core::lex::Token;
-use pgen_core::parse::ParserImpl;
+use pgen_core::parse::{ParserImpl, SExp};
 
 use builder::LR1Configure;
 use driver::LR1Driver;
@@ -24,7 +24,6 @@ where
 {
     type TokenSet = T;
     type Syntax = S;
-    type Output = ();
 
     fn setup() -> anyhow::Result<Self> {
         Ok(LR1(LR1Configure::setup()?))
@@ -33,7 +32,7 @@ where
     fn parse<'b>(
         &self,
         mut lexer: impl Iterator<Item = Token<'a, 'b, T>>,
-    ) -> anyhow::Result<Self::Output> {
+    ) -> anyhow::Result<SExp<'a, 'b, T, S>> {
         LR1Driver::new(&self.0).run(&mut lexer)
     }
 }

crates/core/src/lib.rs

@@ -8,7 +8,7 @@ use std::marker::PhantomData;
 use serde::{Serialize, Deserialize};
 
 use lex::Lexer;
-use parse::ParserImpl;
+use parse::{ParserImpl, SExp};
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Parser<'a, Algorithm>
@@ -31,7 +31,10 @@ where
         })
     }
 
-    pub fn parse<'b>(&self, input: &'b str) -> anyhow::Result<Algorithm::Output> {
+    pub fn parse<'b>(
+        &self,
+        input: &'b str,
+    ) -> anyhow::Result<SExp<'a, 'b, Algorithm::TokenSet, Algorithm::Syntax>> {
         let lexer = Lexer::new::<Algorithm::TokenSet>(input)?;
         self.r#impl.parse(lexer)
     }

crates/core/src/parse.rs

@@ -1,3 +1,5 @@
+use std::fmt::{Display, Debug};
+
 use crate::cfg::{TokenSet, Syntax};
 use crate::lex::Token;
 
@@ -7,11 +9,78 @@ where
 {
     type TokenSet: TokenSet<'a> + 'a;
     type Syntax: Syntax<'a, TokenSet = Self::TokenSet>;
-    type Output;
 
     fn setup() -> anyhow::Result<Self>;
     fn parse<'b>(
         &self,
         lexer: impl Iterator<Item = Token<'a, 'b, Self::TokenSet>>,
-    ) -> anyhow::Result<Self::Output>;
+    ) -> anyhow::Result<SExp<'a, 'b, Self::TokenSet, Self::Syntax>>;
+}
+
+#[derive(Debug)]
+pub enum SExp<'a, 'b, T, S>
+where
+    T: TokenSet<'a> + 'a,
+    S: Syntax<'a, TokenSet = T>,
+{
+    List {
+        tag: S,
+        elems: Vec<SExp<'a, 'b, T, S>>,
+    },
+    Atom(Token<'a, 'b, T>),
+}
+
+impl<'a, T, S> Display for SExp<'a, '_, T, S>
+where
+    T: TokenSet<'a> + 'a,
+    S: Syntax<'a, TokenSet = T> + Debug,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SExp::List { tag, elems } => {
+                write!(f, "({:?}", tag)?;
+                for elem in elems {
+                    write!(f, " {}", elem)?;
+                }
+                write!(f, ")")
+            }
+            SExp::Atom(token) => write!(f, "{:?}", token.as_str()),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SExpBuilder<'a, 'b, T, S>
+where
+    T: TokenSet<'a> + 'a,
+    S: Syntax<'a, TokenSet = T>,
+{
+    stack: Vec<SExp<'a, 'b, T, S>>,
+}
+
+impl<'a, 'b, T, S> SExpBuilder<'a, 'b, T, S>
+where
+    T: TokenSet<'a> + 'a,
+    S: Syntax<'a, TokenSet = T>,
+{
+    pub fn new() -> SExpBuilder<'a, 'b, T, S> {
+        SExpBuilder { stack: vec![] }
+    }
+
+    pub fn push(&mut self, token: Token<'a, 'b, T>) {
+        self.stack.push(SExp::Atom(token));
+    }
+
+    pub fn wrap(&mut self, tag: S, cnt: usize) {
+        let elems = self.stack.split_off(self.stack.len() - cnt);
+        self.stack.push(SExp::List { tag, elems });
+    }
+
+    pub fn build(mut self) -> anyhow::Result<SExp<'a, 'b, T, S>> {
+        if self.stack.len() == 1 {
+            Ok(self.stack.pop().unwrap())
+        } else {
+            Err(anyhow::anyhow!("Invalid S-Expression"))
+        }
+    }
 }

examples/expr.rs

@@ -47,7 +47,7 @@ fn main() -> anyhow::Result<()> {
     stdin().read_line(&mut input)?;
 
     match ExprParser::new()?.parse(&input) {
-        Ok(_) => println!("Accepted"),
+        Ok(sexp) => println!("Accepted : {}", sexp),
         Err(e) => {
             if let Some(e) = e.downcast_ref::<ParseError>() {
                 e.pretty_print();