[add] LALR1 作成 & lalr1 フラグ追加

Author: Yuta1004

Cargo.lock

@@ -18,6 +18,7 @@ copager_parse_lr_common = { path = "./crates/parse_lr_common", optional = true }
 copager_parse_lr_lr0 = { path = "./crates/parse_lr_lr0", optional = true }
 copager_parse_lr_lr1 = { path = "./crates/parse_lr_lr1", optional = true }
 copager_parse_lr_slr1 = { path = "./crates/parse_lr_slr1", optional = true }
+copager_parse_lr_lalr1 = { path = "./crates/parse_lr_lalr1", optional = true }
 copager_ir = { path = "./crates/ir" }
 copager_ir_void = { path = "./crates/ir_void", optional = true }
 copager_ir_sexp = { path = "./crates/ir_sexp", optional = true }
@@ -54,6 +55,7 @@ regexlex = ["dep:copager_lex_regex"]
 lr0 = ["dep:copager_parse_lr_lr0"]
 lr1 = ["dep:copager_parse_lr_lr1"]
 slr1 = ["dep:copager_parse_lr_slr1"]
+lalr1 = ["dep:copager_parse_lr_lalr1"]
 
 # ir
 void = ["dep:copager_ir_void"]
@@ -76,6 +78,7 @@ members = [
     "./crates/parse_lr_lr0",
     "./crates/parse_lr_lr1",
     "./crates/parse_lr_slr1",
+    "./crates/parse_lr_lalr1",
     "./crates/ir",
     "./crates/ir_void",
     "./crates/ir_sexp",

Cargo.toml

@@ -0,0 +1,24 @@
+cargo-features = ["edition2024"]
+
+[package]
+name = "copager_parse_lr_lalr1"
+version = "0.2.0"
+edition = "2024"
+
+[dependencies]
+anyhow = { workspace = true }
+thiserror = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+copager_cfg = { path = "../cfg" }
+copager_lex = { path = "../lex" }
+copager_parse = { path = "../parse" }
+copager_parse_common = { path = "../parse_common" }
+copager_parse_lr_common = { path = "../parse_lr_common" }
+copager_utils = { path = "../utils" }
+
+[dev-dependencies]
+copager_core = { path = "../core" }
+copager_lex = { path = "../lex", features = ["derive"] }
+copager_lex_regex = { path = "../lex_regex" }
+copager_parse = { path = "../parse", features = ["derive"] }
+copager_ir_void = { path = "../ir_void" }

crates/parse_lr_lalr1/Cargo.toml

@@ -0,0 +1,137 @@
+#![feature(gen_blocks)]
+
+use std::marker::PhantomData;
+
+use serde::{Serialize, Deserialize};
+
+use copager_cfg::token::{Token, TokenTag};
+use copager_cfg::rule::{Rule, RuleElem, RuleTag};
+use copager_lex::LexSource;
+use copager_parse::{BaseParser, ParseSource, ParseEvent};
+use copager_parse_common::rule::FirstSet;
+use copager_parse_lr_common::lr1::LR1DFA;
+use copager_parse_lr_common::lalr1::item::LALR1Item;
+use copager_parse_lr_common::lalr1::LALR1DFA;
+use copager_parse_lr_common::{LRDriver, LRAction, LRTable, LRTableBuilder};
+use copager_utils::cache::Cacheable;
+
+pub struct LALR1<T, R>
+where
+    T: TokenTag,
+    R: RuleTag<T>
+{
+    table: LRTable<T, R>,
+}
+
+impl<Sl, Sp> BaseParser<Sl, Sp> for LALR1<Sl::Tag, Sp::Tag>
+where
+    Sl: LexSource,
+    Sp: ParseSource<Sl::Tag>,
+{
+    fn try_from((_, source_p): (Sl, Sp)) -> anyhow::Result<Self> {
+        let table = LALR1Table::try_from(source_p)?;
+        Ok(LALR1 { table })
+    }
+
+    gen fn run<'input, Il>(&self, mut lexer: Il) -> ParseEvent<'input, Sl::Tag, Sp::Tag>
+    where
+        Il: Iterator<Item = Token<'input, Sl::Tag>>,
+    {
+        let mut driver = LRDriver::from(&self.table);
+        while !driver.accepted() {
+            for event in driver.consume(lexer.next()).collect::<Vec<_>>() {
+                yield event;
+            }
+        }
+    }
+}
+
+impl<Sl, Sp> Cacheable<(Sl, Sp)> for LALR1<Sl::Tag, Sp::Tag>
+where
+    Sl: LexSource,
+    Sl::Tag: Serialize + for<'de> Deserialize<'de>,
+    Sp: ParseSource<Sl::Tag>,
+    Sp::Tag: Serialize + for<'de> Deserialize<'de>,
+{
+    type Cache = LRTable<Sl::Tag, Sp::Tag>;
+
+    fn new((_, source_p): (Sl, Sp)) -> anyhow::Result<Self::Cache> {
+        let table = LALR1Table::try_from(source_p)?;
+        Ok(table)
+    }
+
+    fn restore(table: Self::Cache) -> Self {
+        LALR1 { table }
+    }
+}
+
+pub struct LALR1Table<T, R>
+where
+    T: TokenTag,
+    R: RuleTag<T>
+{
+    _phantom_t: PhantomData<T>,
+    _phantom_r: PhantomData<R>,
+}
+
+impl<T, R> LALR1Table<T, R>
+where
+    T: TokenTag,
+    R: RuleTag<T>,
+{
+    fn try_from<Sp>(source_p: Sp) -> anyhow::Result<LRTable<T, R>>
+    where
+        Sp: ParseSource<T, Tag = R>,
+    {
+        // 最上位規則を追加して RuleSet を更新
+        let mut ruleset = source_p.into_ruleset();
+        let top_dummy = Rule::new(
+            None,
+            RuleElem::new_nonterm("__top_dummy"),
+            vec![RuleElem::new_nonterm(&ruleset.top)],
+        );
+        ruleset.update_top(top_dummy.clone());
+
+        // First 集合作成
+        let first_set = FirstSet::from(&ruleset);
+
+        // LALR(1) オートマトン作成
+        let dfa = LR1DFA::from((&ruleset, &first_set));
+        let dfa = LALR1DFA::from(dfa);
+
+        // LALR(1) 構文解析表作成
+        let mut builder = LRTableBuilder::from(&dfa);
+        for node in &dfa.nodes {
+            for (rule, la_tokens) in node.find_all_by(is_lalr1_reduce_state) {
+                // A -> α β . [la_token] を含む場合，la_token 列に対して Reduce をマーク
+                for la_token in la_tokens {
+                    match la_token {
+                        RuleElem::Term(term) => {
+                            builder.try_set(node.id, Some(*term), LRAction::Reduce(rule.clone()))?;
+                        }
+                        RuleElem::EOF => {
+                            builder.try_set(node.id, None, LRAction::Reduce(rule.clone()))?;
+                        }
+                        _ => {}
+                    }
+                }
+
+                // S -> Top . を含む場合，EOF 列に対して Accept をマーク
+                if rule == &top_dummy {
+                    builder.set(node.id, None, LRAction::Accept);
+                }
+            }
+        }
+        let table = builder.build();
+
+        Ok(table)
+    }
+}
+
+fn is_lalr1_reduce_state<T, R>(item: &&LALR1Item<T, R>) -> bool
+where
+    T: TokenTag,
+    R: RuleTag<T>,
+{
+    item.check_next_elem().is_none()
+}

crates/parse_lr_lalr1/src/lib.rs

@@ -0,0 +1,100 @@
+use copager_core::{Language, Processor};
+use copager_cfg::token::TokenTag;
+use copager_cfg::rule::{RuleTag, Rule, RuleElem};
+use copager_lex::LexSource;
+use copager_lex_regex::RegexLexer;
+use copager_parse::ParseSource;
+use copager_parse_lr_lalr1::LALR1;
+use copager_ir_void::Void;
+
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq, LexSource)]
+enum TestToken {
+    #[default]
+    #[token(text = r"\+")]
+    Plus,
+    #[token(text = r"-")]
+    Minus,
+    #[token(text = r"\*")]
+    Mul,
+    #[token(text = r"/")]
+    Div,
+    #[token(text = r"\(")]
+    BracketL,
+    #[token(text = r"\)")]
+    BracketR,
+    #[token(text = r"[1-9][0-9]*")]
+    Num,
+    #[token(text = r"[ \t\n]+", ignored)]
+    _Whitespace,
+}
+
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq, ParseSource)]
+enum TestRule {
+    #[default]
+    #[rule("<expr> ::= <expr> Plus <term>")]
+    #[rule("<expr> ::= <expr> Minus <term>")]
+    #[rule("<expr> ::= <term>")]
+    Expr,
+    #[rule("<term> ::= <term> Mul <num>")]
+    #[rule("<term> ::= <term> Div <num>")]
+    #[rule("<term> ::= <num>")]
+    Term,
+    #[rule("<num> ::= BracketL <expr> BracketR")]
+    #[rule("<num> ::= Num")]
+    Num,
+}
+
+type TestLanguage = Language<TestToken, TestRule>;
+type TestLexer = RegexLexer<TestToken>;
+type TestParser = LALR1<TestToken, TestRule>;
+type TestProcessor = Processor<TestLanguage, TestLexer, TestParser>;
+
+#[test]
+fn simple_success() {
+    const OK_INPUTS: [&str; 10] = [
+        "10",
+        "10 + 20",
+        "10 - 20",
+        "10 * 20",
+        "10 / 20",
+        "10 + 20 * 30 - 40",
+        "(10)",
+        "((((10))))",
+        "10 * (20 - 30)",
+        "((10 + 20) * (30 / 40)) - 50",
+    ];
+
+    let processor = TestProcessor::new()
+        .build_lexer()
+        .unwrap()
+        .build_parser()
+        .unwrap();
+
+    for input in &OK_INPUTS {
+        println!("input: {}", input);
+        processor.process::<Void>(input).unwrap();
+    }
+}
+
+#[test]
+fn simple_failure() {
+    const ERR_INPUTS: [&str; 7] = [
+        "()",
+        "(10 -",
+        "10 +",
+        "*",
+        "10 20 + 30",
+        "10 + 20 * 30 / 40 (",
+        "(((10))",
+    ];
+
+    let processor = TestProcessor::new()
+        .build_lexer()
+        .unwrap()
+        .build_parser()
+        .unwrap();
+
+    for input in &ERR_INPUTS {
+        assert!(processor.process::<Void>(input).is_err(), "input: {}", input);
+    }
+}

crates/parse_lr_lalr1/tests/simple.rs

@@ -22,6 +22,10 @@ pub mod parse {
     pub use copager_parse_lr_lr0::*;
     #[cfg(feature = "lr1")]
     pub use copager_parse_lr_lr1::*;
+    #[cfg(feature = "slr1")]
+    pub use copager_parse_lr_slr1::*;
+    #[cfg(feature = "lalr1")]
+    pub use copager_parse_lr_lalr1::*;
 }
 
 pub mod ir {