Defines lr1 parser

Author: Maxcode123

src/syntactes/parser/__init__.py

@@ -1,3 +1,3 @@
 from .exception import NotAcceptedError, ParserError, UnexpectedTokenError
 from .execute import ExecutablesRegistry, execute_on
-from .parser import LR0Parser, SLRParser
+from .parser import LR0Parser, SLRParser, LR1Parser

src/syntactes/parser/parser.py

@@ -1,7 +1,8 @@
+from abc import ABC
 from collections import deque
-from typing import Iterable
+from typing import Iterable, Type
 
-from syntactes import Grammar, LR0Generator, SLRGenerator, Token
+from syntactes import Grammar, LR0Generator, LR1Generator, SLRGenerator, Token
 from syntactes._action import Action, ActionType
 from syntactes._state import LR0State
 from syntactes.parser import (
@@ -10,28 +11,26 @@
     ParserError,
     UnexpectedTokenError,
 )
-from syntactes.parsing_table import LR0ParsingTable
+from syntactes.parsing_table import ParsingTable
 
 
-class LR0Parser:
-    """
-    Parses streams of tokens based on the configured parsing table.
-    """
+class Parser(ABC):
+    generator_cls: Type
 
-    def __init__(self, table: LR0ParsingTable) -> None:
+    def __init__(self, table: ParsingTable) -> None:
         self._table = table
         self._token_stack: deque[Token] = deque()
         self._state_stack: deque[LR0State] = deque()
         self._token_stream: deque[Token] = deque()
 
-    @staticmethod
-    def from_grammar(grammar: Grammar) -> "LR0Parser":
+    @classmethod
+    def from_grammar(cls, grammar: Grammar) -> "Parser":
         """
         Create a parser for the given grammar.
         """
-        generator = LR0Generator(grammar)
+        generator = cls.generator_cls(grammar)
         parsing_table = generator.generate()
-        parser = LR0Parser(parsing_table)
+        parser = cls(parsing_table)
         return parser
 
     def parse(self, stream: Iterable[Token]) -> None:
@@ -107,17 +106,13 @@ def _raise(self, error: ParserError) -> None:
         raise error from None
 
 
-class SLRParser(LR0Parser):
-    """
-    Parses streams of tokens based on the configured parsing table.
-    """
+class LR0Parser(Parser):
+    generator_cls = LR0Generator
 
-    @staticmethod
-    def from_grammar(grammar: Grammar) -> "SLRParser":
-        """
-        Create a parser for the given grammar.
-        """
-        generator = SLRGenerator(grammar)
-        parsing_table = generator.generate()
-        parser = SLRParser(parsing_table)
-        return parser
+
+class SLRParser(Parser):
+    generator_cls = SLRGenerator
+
+
+class LR1Parser(Parser):
+    generator_cls = LR1Generator

src/syntactes/tests/test_parser.py

@@ -4,14 +4,18 @@
 from syntactes.parser import (
     ExecutablesRegistry,
     LR0Parser,
+    LR1Parser,
     ParserError,
     SLRParser,
     execute_on,
 )
 from syntactes.tests.data import (
     EOF,
+    LPAREN,
     PLUS,
+    RPAREN,
     lr0_parsing_table,
+    lr1_parsing_table,
     rule_2_1,
     rule_4_1,
     slr_parsing_table,
@@ -144,3 +148,31 @@ def test_x_x_eof_raises(self):
     @args(x, PLUS, x, EOF)
     def test_x_plus_x(self):
         self.result()
+
+
+class TestLR1Parser(TestCase):
+    def parser(self):
+        return self._parser
+
+    def setUp(self):
+        self._parser = LR1Parser(lr1_parsing_table())
+
+    def assert_parser_error(self):
+        self.assertResultRaises(ParserError)
+
+
+class TestLR1ParserParse(TestLR1Parser):
+    def subject(self, *stream):
+        return self.parser().parse(stream)
+
+    @args(LPAREN, RPAREN)
+    def test_no_eof_raises(self):
+        self.assert_parser_error()
+
+    @args(LPAREN, RPAREN, EOF)
+    def test_valid_syntax_does_not_raise(self):
+        self.result()
+
+    @args(LPAREN, RPAREN, RPAREN, EOF)
+    def test_invalid_syntax_raises(self):
+        self.assert_parser_error()