test: add lrparser rust implementation

Author: jnoortheen

ply_parser/ply/lrparser.py

@@ -28,6 +28,15 @@
 error_count: Final = 3  # Number of symbols that must be shifted to leave recovery mode
 
 
+try:
+    from rs_ply import LRParser as RustLRParser
+    from rs_ply import StateMachine as RustStateMachine
+
+    HAS_RS_PLY = True
+except ImportError:
+    HAS_RS_PLY = False
+
+
 @dataclass(slots=True)
 class LexToken:
     """keep for backward compatibility and name distinction"""
@@ -573,9 +582,16 @@ def expect_goto(self, state: int, sym: str) -> int:
         return self.gotos[state][sym]
 
 
-def load_parser(parser_table: Path | str, module: ParserProtocol) -> LRParser:
+def load_parser(parser_table: Path | str, module: ParserProtocol) -> Union[LRParser, "RustLRParser"]:
     if isinstance(parser_table, Path):
         parser_table = str(parser_table)
 
+    if HAS_RS_PLY and parser_table.endswith(".jsonl"):
+        try:
+            fsm = RustStateMachine.new_from_file(parser_table)
+            return RustLRParser(fsm, module, errorf=getattr(module, "p_error", None))
+        except Exception:
+            pass
+
     fsm = StateMachine(parser_table)
     return LRParser(fsm, errorf=getattr(module, "p_error", None), module=module)

rs-ply/src/data.rs

@@ -92,20 +92,20 @@ impl StateMachine {
         })
     }
 
-    fn get_default_action(&self, state: u16) -> Option<i16> {
+    pub fn get_default_action(&self, state: u16) -> Option<i16> {
         self.defaults.get(&state).copied()
     }
 
-    fn get_action(&self, state: usize, sym: &str) -> Option<i16> {
+    pub fn get_action(&self, state: usize, sym: &str) -> Option<i16> {
         let symbols = self.actions.get(state).unwrap();
         let action = symbols.get(sym);
         action.map(|x| *x)
     }
-    fn expect_production(&self, index: usize) -> Production {
+    pub fn expect_production(&self, index: usize) -> Production {
         let prod = self.productions.get(index).unwrap();
         prod.clone()
     }
-    fn expect_goto(&self, state: usize, sym: &str) -> PyResult<u16> {
+    pub fn expect_goto(&self, state: usize, sym: &str) -> PyResult<u16> {
         let gotos = self
             .gotos
             .get(state)

rs-ply/src/lib.rs

@@ -7,6 +7,9 @@ use pyo3::prelude::*;
 /// A Python module implemented in Rust.
 #[pymodule]
 fn rs_ply(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_class::<data::StateMachine>()?;
+    m.add_class::<data::Production>()?;
+    m.add_class::<yacc_types::YaccSymbol>()?;
+    m.add_class::<yacc_types::YaccProduction>()?;
+    m.add_class::<lrparser::LRParser>()?;
     Ok(())
 }