Merge branch 'conflict-model'

Author: Maxcode123

Makefile

@@ -1,5 +1,5 @@
 clean:
-	rm -rf src/syntactes/__pycache__ src/syntactes/tests/__pycache__ src/syntactes/parser/__pycache__
+	rm -rf src/syntactes/__pycache__ src/syntactes/tests/__pycache__ src/syntactes/parser/__pycache__ src/syntactes/parsing_table/__pycache__
 	rm -rf dist src/syntactes.egg-info
 
 test:

src/syntactes/__init__.py

@@ -2,4 +2,3 @@
 from .rule import Rule
 from .grammar import Grammar
 from .generator import LR0Generator, SLRGenerator
-from .table import LR0ParsingTable, SLRParsingTable

src/syntactes/generator.py

@@ -1,8 +1,8 @@
 from syntactes import Grammar, Token
-from syntactes._action import Action, ActionType
+from syntactes._action import Action
 from syntactes._item import LR0Item
 from syntactes._state import LR0State
-from syntactes.table import Entry, LR0ParsingTable, SLRParsingTable
+from syntactes.parsing_table import Entry, LR0ParsingTable, SLRParsingTable
 
 
 class LR0Generator:

src/syntactes/parser/parser.py

@@ -10,7 +10,7 @@
     ParserError,
     UnexpectedTokenError,
 )
-from syntactes.table import LR0ParsingTable
+from syntactes.parsing_table import LR0ParsingTable
 
 
 class LR0Parser:

src/syntactes/parsing_table/__init__.py

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

src/syntactes/parsing_table/conflict.py

@@ -0,0 +1,66 @@
+from enum import Enum
+
+from syntactes import Token
+from syntactes._action import Action, ActionType
+from syntactes._state import LR0State
+
+
+class ConflictType(Enum):
+    SHIFT_SHIFT = "shift/shift"
+    SHIFT_REDUCE = "shift/reduce"
+    REDUCE_REDUCE = "reduce/reduce"
+    NO_CONFLICT = "NO_CONFLICT"
+
+
+class Conflict:
+    def __init__(self, state: LR0State, token: Token, actions: list[Action]) -> None:
+        self.state = state
+        self.token = token
+        self.actions = actions
+        self._conflict_type = None
+
+    def pretty_str(self) -> str:
+        """
+        Returns a pretty-formatted string with conflict details.
+        """
+        string = f"{self.conflict_type.value} conflict in state {self.state}\n"
+        string += f"Available actions on input token '{self.token}':\n"
+        for action in self.actions:
+            if action.action_type == ActionType.SHIFT:
+                string += f"shift to {action.actionable}\n"
+            elif action.action_type == ActionType.REDUCE:
+                string += f"reduce by {action.actionable}\n"
+            else:
+                string += f"{action.action_type}, {action.actionable}\n"
+
+        return string
+
+    @property
+    def conflict_type(self) -> ConflictType:
+        if self._conflict_type is None:
+            self._conflict_type = self._create_type()
+
+        return self._conflict_type
+
+    def _create_type(self) -> ConflictType:
+        if not len(self.actions) > 1:
+            return ConflictType.NO_CONFLICT
+
+        action_types = set(map(lambda a: a.action_type, self.actions))
+
+        if ActionType.SHIFT not in action_types:
+            if ActionType.REDUCE not in action_types:
+                return ConflictType.NO_CONFLICT
+
+            return ConflictType.REDUCE_REDUCE
+
+        if ActionType.REDUCE not in action_types:
+            return ConflictType.SHIFT_SHIFT
+
+        return ConflictType.SHIFT_REDUCE
+
+    def __repr__(self) -> str:
+        return f"<Conflict: {str(self)}>"
+
+    def __str__(self) -> str:
+        return f"{self.state}, {self.token}, {self.actions}"

src/syntactes/parsing_table/entry.py

@@ -0,0 +1,38 @@
+from typing import TypeAlias
+
+from syntactes import Token
+from syntactes._action import Action
+from syntactes._state import LR0State
+
+Row: TypeAlias = dict[Token, list[Action]]
+
+
+class Entry:
+    """
+    An entry of the parsing table. Holds the information of a transition from
+    a state to another state via a symbol.
+    """
+
+    def __init__(self, from_state: LR0State, token: Token, action: Action) -> None:
+        self.from_state = from_state
+        self.token = token
+        self.action = action
+
+    def __repr__(self) -> str:
+        return f"<Entry: {str(self)}>"
+
+    def __str__(self) -> str:
+        return f"{self.from_state.number}, {self.action}, {self.token}"
+
+    def __hash__(self) -> int:
+        return hash((self.from_state, self.token, self.action))
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, Entry):
+            return False
+
+        return (
+            self.from_state == other.from_state
+            and self.token == other.token
+            and self.action == other.action
+        )

src/syntactes/table.py src/syntactes/parsing_table/table.pysrc/syntactes/table.py renamed to src/syntactes/parsing_table/table.py

@@ -3,41 +3,11 @@
 from syntactes import Grammar, Token
 from syntactes._action import Action
 from syntactes._state import LR0State
+from syntactes.parsing_table import Conflict, Entry
 
 Row: TypeAlias = dict[Token, list[Action]]
 
 
-class Entry:
-    """
-    An entry of the parsing table. Holds the information of a transition from
-    a state to another state via a symbol.
-    """
-
-    def __init__(self, from_state: LR0State, token: Token, action: Action) -> None:
-        self.from_state = from_state
-        self.token = token
-        self.action = action
-
-    def __repr__(self) -> str:
-        return f"<Entry: {str(self)}>"
-
-    def __str__(self) -> str:
-        return f"{self.from_state.number}, {self.action}, {self.token}"
-
-    def __hash__(self) -> int:
-        return hash((self.from_state, self.token, self.action))
-
-    def __eq__(self, other) -> bool:
-        if not isinstance(other, Entry):
-            return False
-
-        return (
-            self.from_state == other.from_state
-            and self.token == other.token
-            and self.action == other.action
-        )
-
-
 class LR0ParsingTable:
     """
     Table that contains all the transitions from state to state with a symbol.
@@ -48,6 +18,21 @@ def __init__(self, grammar: Grammar) -> None:
         self._grammar = grammar
         self._initial_state = None
 
+    @staticmethod
+    def from_entries(
+        entries: Iterable[Entry], tokens: Iterable[Token]
+    ) -> "LR0ParsingTable":
+        """
+        Create a parsing table from the given entries.
+        """
+        table = LR0ParsingTable(tokens)
+        {table.add_entry(entry) for entry in entries}
+        return table
+
+    @property
+    def initial_state(self) -> LR0State:
+        return self._initial_state
+
     def get_actions(self, state: LR0State, token: Token) -> Optional[list[Action]]:
         """
         Get the actions from state with given number with `token`.
@@ -73,26 +58,23 @@ def add_entry(self, entry: Entry) -> None:
         actions = row.setdefault(entry.token, list())
         actions.append(entry.action)
 
-    @staticmethod
-    def from_entries(
-        entries: Iterable[Entry], tokens: Iterable[Token]
-    ) -> "LR0ParsingTable":
-        """
-        Create a parsing table from the given entries.
-        """
-        table = LR0ParsingTable(tokens)
-        {table.add_entry(entry) for entry in entries}
-        return table
-
     def pretty_str(self) -> str:
         """
         Returns a pretty-formatted string representation of the table.
         """
         return self._rules_pretty_str() + "\n\n" + self._table_pretty_str()
 
-    @property
-    def initial_state(self) -> LR0State:
-        return self._initial_state
+    def conflicts(self) -> list[Conflict]:
+        """
+        Retuns a list with all the conflicts in the parsing table.
+        """
+        conflicts = []
+        for state, row in self.rows.items():
+            for token, actions in row.items():
+                if len(actions) > 1:
+                    conflicts.append(Conflict(state, token, actions))
+
+        return conflicts
 
     def _rules_pretty_str(self) -> str:
         rules = [str(i) + ". " + str(r) for i, r in enumerate(self._grammar.rules)]

src/syntactes/tests/data.py

@@ -2,7 +2,7 @@
 from syntactes._action import Action
 from syntactes._item import LR0Item
 from syntactes._state import LR0State
-from syntactes.table import Entry, LR0ParsingTable, SLRParsingTable
+from syntactes.parsing_table import Entry, LR0ParsingTable, SLRParsingTable
 
 EOF = Token.eof()
 S = Token("S", False)