Defines lr1 parsing table

Author: Maxcode123

src/syntactes/parsing_table/__init__.py

@@ -1,3 +1,3 @@
 from .entry import Entry
 from .conflict import Conflict, ConflictType
-from .table import LR0ParsingTable, SLRParsingTable
+from .table import LR0ParsingTable, SLRParsingTable, LR1ParsingTable, ParsingTable

src/syntactes/parsing_table/table.py

@@ -1,13 +1,24 @@
-from typing import Iterable, Optional, TypeAlias
+from typing import Iterable, Optional, Protocol, TypeAlias
 
 from syntactes import Grammar, Token
 from syntactes._action import Action
-from syntactes._state import LR0State
+from syntactes._state import LR0State, LR1State, State
 from syntactes.parsing_table import Conflict, Entry
 
 Row: TypeAlias = dict[Token, list[Action]]
 
 
+class ParsingTable(Protocol):
+    rows: dict[State, Row]
+    initial_state: State
+
+    @staticmethod
+    def from_entries(entries: Iterable[Entry], grammar: Grammar) -> "ParsingTable": ...
+
+    def get(self, state: State) -> Optional[Row]: ...
+
+    def get_actions(self, state: State, token: Token) -> Optional[list[Action]]: ...
+
 class LR0ParsingTable:
     """
     Table that contains all the transitions from state to state with a symbol.
@@ -19,13 +30,11 @@ def __init__(self, grammar: Grammar) -> None:
         self._initial_state = None
 
     @staticmethod
-    def from_entries(
-        entries: Iterable[Entry], tokens: Iterable[Token]
-    ) -> "LR0ParsingTable":
+    def from_entries(entries: Iterable[Entry], grammar: Grammar) -> "LR0ParsingTable":
         """
         Create a parsing table from the given entries.
         """
-        table = LR0ParsingTable(tokens)
+        table = LR0ParsingTable(grammar)
         {table.add_entry(entry) for entry in entries}
         return table
 
@@ -133,3 +142,46 @@ def from_entries(
 
     def _header_str(self) -> str:
         return "SLR PARSING TABLE"
+
+
+class LR1ParsingTable(LR0ParsingTable):
+    """
+    Table that contains all the transitions from state to state with a symbol.
+    """
+
+    def __init__(self, grammar: Grammar) -> None:
+        self.rows: dict[LR1State, Row] = dict()
+        self._grammar = grammar
+        self._initial_state = None
+
+    @staticmethod
+    def from_entries(
+        entries: Iterable[Entry], tokens: Iterable[Token]
+    ) -> "LR1ParsingTable":
+        """
+        Create a parsing table from the given entries.
+        """
+        table = LR1ParsingTable(tokens)
+        {table.add_entry(entry) for entry in entries}
+        return table
+
+    @property
+    def initial_state(self) -> LR1State:
+        return self._initial_state
+
+    def get_actions(self, state: LR1State, token: Token) -> Optional[list[Action]]:
+        """
+        Get the actions from state with given number with `token`.
+        If there are no actions, returns None.
+        """
+        return self.rows.get(state, {}).get(token, None)
+
+    def get(self, state: LR1State) -> Optional[Row]:
+        """
+        Get the mapping of tokens to actions for the given state number.
+        Returns None if the state is not found.
+        """
+        return self.rows.get(state, None)
+
+    def _header_str(self) -> str:
+        return "LR1 PARSING TABLE"

src/syntactes/tests/data.py

@@ -2,7 +2,7 @@
 from syntactes._action import Action
 from syntactes._item import LR0Item, LR1Item
 from syntactes._state import LR0State, LR1State
-from syntactes.parsing_table import Entry, LR0ParsingTable, SLRParsingTable
+from syntactes.parsing_table import Entry, LR0ParsingTable, SLRParsingTable, LR1ParsingTable
 
 EOF = Token.eof()
 S = Token("S", False)
@@ -250,3 +250,32 @@ def lr1_state_12():
     state = LR1State.from_items({item_1})
     state.set_number(12)
     return state
+
+
+def lr1_parsing_table():
+    table = LR1ParsingTable(grammar_1)
+    table.add_entry(Entry(lr1_state_1(), L, Action.shift(lr1_state_2())))
+    table.add_entry(Entry(lr1_state_1(), C, Action.shift(lr1_state_3())))
+    table.add_entry(Entry(lr1_state_1(), LPAREN, Action.shift(lr1_state_4())))
+    table.add_entry(Entry(lr1_state_2(), C, Action.shift(lr1_state_5())))
+    table.add_entry(Entry(lr1_state_2(), LPAREN, Action.shift(lr1_state_4())))
+    table.add_entry(Entry(lr1_state_2(), EOF, Action.accept()))
+    table.add_entry(Entry(lr1_state_3(), LPAREN, Action.reduce(rule_3_2)))
+    table.add_entry(Entry(lr1_state_3(), EOF, Action.reduce(rule_3_2)))
+    table.add_entry(Entry(lr1_state_4(), C, Action.shift(lr1_state_6())))
+    table.add_entry(Entry(lr1_state_4(), LPAREN, Action.shift(lr1_state_7())))
+    table.add_entry(Entry(lr1_state_4(), RPAREN, Action.shift(lr1_state_8())))
+    table.add_entry(Entry(lr1_state_5(), LPAREN, Action.reduce(rule_2_2)))
+    table.add_entry(Entry(lr1_state_5(), RPAREN, Action.reduce(rule_2_2)))
+    table.add_entry(Entry(lr1_state_6(), RPAREN, Action.shift(lr1_state_9())))
+    table.add_entry(Entry(lr1_state_7(), LPAREN, Action.shift(lr1_state_7())))
+    table.add_entry(Entry(lr1_state_7(), RPAREN, Action.shift(lr1_state_11())))
+    table.add_entry(Entry(lr1_state_7(), C, Action.shift(lr1_state_10())))
+    table.add_entry(Entry(lr1_state_8(), LPAREN, Action.reduce(rule_5_2)))
+    table.add_entry(Entry(lr1_state_8(), EOF, Action.reduce(rule_5_2)))
+    table.add_entry(Entry(lr1_state_9(), LPAREN, Action.reduce(rule_4_2)))
+    table.add_entry(Entry(lr1_state_9(), EOF, Action.reduce(rule_4_2)))
+    table.add_entry(Entry(lr1_state_10(), RPAREN, Action.shift(lr1_state_12)))
+    table.add_entry(Entry(lr1_state_11(), RPAREN, Action.reduce(rule_5_2)))
+    table.add_entry(Entry(lr1_state_12(), RPAREN, Action.reduce(rule_4_2)))
+    return table