syntactes 0.1.0__tar.gz

syntactes-0.1.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: syntactes
+Version: 0.1.0
+Summary: Parser generator
+Author-email: Maximos Nikiforakis <nikiforos@live.co.uk>
+License: MIT
+Project-URL: Homepage, https://github.com/Maxcode123/syntactes
+Project-URL: Issues, https://github.com/Maxcode123/syntactes/issues
+Keywords: parser,generator
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown

syntactes-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["syntactes"]
+exclude = ["syntactes.tests*"]
+namespaces = false
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "syntactes"
+version = "0.1.0"
+authors = [
+  { name="Maximos Nikiforakis", email="nikiforos@live.co.uk" }
+]
+description = "Parser generator"
+keywords = ["parser", "generator"]
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+dependencies = []
+classifiers = [
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Natural Language :: English",
+  "License :: OSI Approved :: MIT License",
+  "Topic :: Software Development :: Compilers",
+]
+
+[project.urls]
+Homepage = "https://github.com/Maxcode123/syntactes"
+Issues = "https://github.com/Maxcode123/syntactes/issues"

syntactes-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

syntactes-0.1.0/src/syntactes/__init__.py

@@ -0,0 +1,4 @@
+from .generator import LR0Generator
+from .grammar import Grammar
+from .rule import Rule
+from .token import Token

syntactes-0.1.0/src/syntactes/_action.py

@@ -0,0 +1,65 @@
+from typing import Protocol
+from enum import Enum
+
+
+class Actionable(Protocol):
+    """
+    State or Rule.
+    """
+
+    number: int
+
+
+class ActionType(Enum):
+    SHIFT = "SHIFT"
+    REDUCE = "REDUCE"
+    ACCEPT = "ACCEPT"
+    REJECT = "REJECT"
+
+    def abbreviated(self) -> str:
+        """
+        Returns an abbreviated version of the action type.
+        """
+        if self == self.SHIFT:
+            return "s"
+        if self == self.REDUCE:
+            return "r"
+        if self == self.ACCEPT:
+            return "a"
+        if self == self.REJECT:
+            return "e"
+
+
+class Action:
+    """
+    Parsing action. Contains data relevant to the actionable object (State or Rule)
+    and the relevant action to be applied.
+
+    The `actionable_number` refers to the state number for `State` actionables and
+    to the rule number for `Rule` actionables.
+    """
+
+    def __init__(self, actionable: Actionable, action_type: ActionType) -> None:
+        self.actionable = actionable
+        self.action_type = action_type
+
+    def __repr__(self) -> str:
+        return f"<Action: {self}>"
+
+    def __str__(self) -> str:
+        if self.action_type in {ActionType.ACCEPT, ActionType.REJECT}:
+            return str(self.action_type.abbreviated())
+
+        return f"{self.action_type.abbreviated()}{self.actionable.number}"
+
+    def __hash__(self) -> int:
+        return hash((self.actionable, self.action_type))
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, Action):
+            return False
+
+        return (
+            self.actionable == other.actionable
+            and self.action_type == other.action_type
+        )

syntactes-0.1.0/src/syntactes/_item.py

@@ -0,0 +1,61 @@
+from typing import Optional
+
+from syntactes.rule import Rule
+from syntactes.token import Token
+
+
+class LR0Item:
+    """
+    Item of LR0 parser. Contains rule and current position in rule.
+    Current position is denoted with the dot '.'.
+    """
+
+    def __init__(self, rule: Rule, position: int) -> None:
+        self.rule = rule
+        self.position = position
+
+    def dot_is_last(self) -> bool:
+        """
+        Returns True if the dot in the item is in the last position of the rhs,
+        False otherwise.
+        """
+        return self.position == self.rule.rhs_len
+
+    @property
+    def after_dot(self) -> Optional[Token]:
+        """
+        Returns the symbol after the dot in the current item.
+        If the dot is in the last position, returns None
+        """
+        if self.dot_is_last():
+            return None
+
+        return self.rule.rhs[self.position]
+
+    @property
+    def before_dot(self) -> Optional[Token]:
+        """
+        Returns the symbol before the dot in the current item.
+        If the dot is in the first position, returns None.
+        """
+        if self.position == 0:
+            return None
+
+        return self.rule.rhs[self.position - 1]
+
+    def __repr__(self) -> str:
+        return f"<LR0Item: {self}>"
+
+    def __str__(self) -> str:
+        rhs = [s for s in self.rule.rhs]
+        rhs.insert(self.position, ".")
+        return f"{self.rule.lhs} -> " + " ".join(map(str, rhs))
+
+    def __hash__(self) -> int:
+        return hash((self.rule, self.position))
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, LR0Item):
+            return False
+
+        return self.rule == other.rule and self.position == other.position

syntactes-0.1.0/src/syntactes/_state.py

@@ -0,0 +1,60 @@
+from typing import Iterable, Protocol
+
+from syntactes._item import LR0Item
+
+
+class State(Protocol):
+    """
+    State of parser automaton. A state is a set of items.
+    """
+
+    items: set
+
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def __hash__(self) -> int: ...
+    def __eq__(self) -> bool: ...
+
+
+class LR0State:
+    """
+    State of LR0 parser. A LR0 state is a set of LR0 items.
+    """
+
+    def __init__(self) -> None:
+        self.number = None
+        self.items = set()
+
+    @staticmethod
+    def from_items(items: Iterable[LR0Item]) -> "LR0State":
+        """
+        Create an LR0 state from a set of LR0 items.
+        """
+        state = LR0State()
+        {state.add_item(item) for item in items}
+
+        return state
+
+    def add_item(self, item: LR0Item) -> None:
+        """
+        Adds an item to the state.
+        """
+        self.items.add(item)
+
+    def set_number(self, number: int) -> None:
+        self.number = number
+
+    def __repr__(self) -> str:
+        return f"<LR0State: {self.number}>"
+
+    def __str__(self) -> str:
+        return f"{self.number}:" + "(" + ", ".join(map(str, self.items)) + ")"
+
+    def __hash__(self) -> int:
+        return hash(frozenset(self.items))
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, LR0State):
+            return False
+
+        return self.items == other.items

syntactes-0.1.0/src/syntactes/generator.py

@@ -0,0 +1,255 @@
+from syntactes._action import Action, ActionType
+from syntactes._item import LR0Item
+from syntactes._state import LR0State
+from syntactes.grammar import Grammar
+from syntactes.table import Entry, ParsingTable
+from syntactes.token import Token
+
+
+class LR0Generator:
+    """
+    Generator of LR0 parsing tables.
+    """
+
+    def __init__(self, grammar: Grammar) -> None:
+        self.grammar = grammar
+
+    def generate(self) -> ParsingTable:
+        """
+        Generates an LR0 parsing table for the configured grammar.
+        """
+        states, shift_entries = self._create_states_and_shift_entries()
+        reduce_entries = self._create_reduce_entries(states)
+
+        entries = shift_entries | reduce_entries
+
+        table = ParsingTable.from_entries(entries, self.grammar)
+
+        return table
+
+    def closure(self, items: set[LR0Item]) -> set[LR0Item]:
+        """
+        Computes and returns the closure for the given set of items.
+
+        The closure operation adds more items to a set of items when there
+        is a dot to the left of a non-terminal symbol.
+
+        e.g.
+        for any item S -> . E in the given items, closure adds E -> . T
+        and T -> . x, where E -> T and T -> x are production rules.
+        """
+        _set = {item for item in items}
+
+        for item in items:
+            if item.dot_is_last():
+                continue
+
+            new_items = self._get_related_items(item.after_dot)
+            _set |= new_items
+
+        return _set
+
+    def goto(self, items: set[LR0Item], token: Token) -> set[LR0Item]:
+        """
+        Computes and returns the GOTO set for the given set of items.
+
+        The goto operation creates a set where all items have the dot past the
+        given symbol.
+        """
+        _set: set[LR0Item] = set()
+
+        for item in items:
+            if item.dot_is_last() or item.after_dot != token:
+                continue
+
+            next_item = LR0Item(item.rule, item.position + 1)
+            _set.add(next_item)
+
+        return self.closure(_set)
+
+    def get_states(self) -> set[LR0State]:
+        """
+        Returns the set of automaton states for the configured grammar.
+        """
+        states, _ = self._create_states_and_shift_entries()
+        return states
+
+    def _first(self, symbol: Token) -> set[Token]:
+        """
+        Computes and returns the FIRST set for the given symbol.
+
+        The FIRST set of a symbol 'G' is the set of terminal symbols that are
+        first in the right-hand side of a rule where 'G' is the left-hand side.
+
+        e.g. 't', 'k' and 'a' would be the FIRST set of G for the below rules:
+        1. G -> t
+        2. G -> kM
+        3. G -> T
+        4. T -> a
+        where M is either terminal or non-terminal and T is non-terminal.
+        'a' would be included in the FIRST set because if rule 4 is substituted in
+        rule 3, 'a' (which is a terminal) could be derived from 'G'.
+        """
+        if symbol.is_terminal:
+            return {symbol}
+
+        _set: set[Token] = set()
+
+        for rule in self.grammar.rules:
+            if rule.lhs != symbol:
+                continue
+
+            if rule.rhs[0].is_terminal:
+                _set.add(rule.rhs[0])
+            elif rule.rhs_len == 1:
+                _set |= self._first(rule.rhs[0])
+
+        return _set
+
+    def _follow(self, symbol: Token) -> set[Token]:
+        """
+        Computes and returns the FOLLOW set for the given symbol.
+
+        The FOLLOW set of a symbol 'G' is the set of terminals that can immediately
+        follow 'G' in a rule.
+        """
+        if symbol.is_terminal:
+            return set()
+
+        _set: set[Token] = set()
+
+        for rule in self.grammar.rules:
+            for i, s in enumerate(rule.rhs):
+                if s != symbol:
+                    continue
+
+                if i == rule.rhs_len - 1:
+                    if rule.lhs == symbol:
+                        continue
+
+                    _set |= self._follow(rule.lhs)
+                else:
+                    _set |= self._first(rule.rhs[i + 1])
+
+        return _set
+
+    def _get_related_items(self, symbol: Token) -> set[LR0Item]:
+        """
+        e.g. the items X -> .g, Y -> .p would be returned for the below grammar rules:
+        1. X -> g
+        2. X -> Y
+        3. Y -> p
+        where 'g' and 'p' are terminals.
+        """
+        _set: set[LR0Item] = set()
+
+        for rule in self.grammar.rules:
+            if rule.lhs == symbol:
+                _set.add(LR0Item(rule, 0))
+
+                if rule.rhs_len == 1 and not rule.rhs[0].is_terminal:
+                    _set |= self._get_related_items(rule.rhs[0])
+
+        return _set
+
+    def _create_states_and_shift_entries(self) -> tuple[set[LR0State], set[Entry]]:
+        """
+        Computes and returns the states and entries for shift actions.
+        """
+        states, entries = dict(), set()
+
+        initial_items = self.closure({LR0Item(self.grammar.starting_rule, 0)})
+        initial_state = LR0State.from_items(initial_items)
+        initial_state.set_number(1)
+        states[initial_state] = 1
+
+        _states, _entries = dict(), set()
+        while (_states, _entries) != (states, entries):
+            _states = {s: n for s, n in states.items()}
+            _entries = {e for e in entries}
+            states, entries = self._extend_states_and_shift_entries(_states, _entries)
+
+        return set(states.keys()), entries
+
+    def _extend_states_and_shift_entries(
+        self, states: dict[LR0State, int], entries: set[Entry]
+    ) -> tuple[dict[LR0State, int], set[Entry]]:
+        """
+        Extends states and entries following the below algorithm:
+
+        ```
+        for each state S in states
+            for each item A -> a.Xb in S
+                J = goto(S, X)
+                states.add(J)
+                entries.add((S->J, X))
+        ```
+        """
+        _states = {s: n for s, n in states.items()}
+        _entries = {e for e in entries}
+
+        EOF = Token.eof()
+        for state in states:
+            for item in state.items:
+                if item.dot_is_last() or item.after_dot == EOF:
+                    continue
+
+                new_items = self.goto(state.items, item.after_dot)
+
+                if len(new_items) == 0:
+                    continue
+
+                new = LR0State.from_items(new_items)
+
+                number = _states.setdefault(new, len(_states) + 1)
+                new.set_number(number)
+
+                action = Action(new, ActionType.SHIFT)
+                _entries.add(Entry(state, item.after_dot, action))
+
+        return _states, _entries
+
+    def _create_reduce_entries(self, states: set[LR0State]) -> set[Entry]:
+        """
+        Computes and returns the entries for reduce actions and the accept action.
+        """
+        entries: set[Entry] = set()
+
+        for state in states:
+            for item in state.items:
+                if item.after_dot == Token.eof():
+                    action = Action(item.rule, ActionType.ACCEPT)
+                    entries.add(Entry(state, Token.eof(), action))
+
+                if not item.dot_is_last():
+                    continue
+
+                action = Action(item.rule, ActionType.REDUCE)
+                for token in self.grammar.tokens:
+                    if token.is_terminal:
+                        entries.add(Entry(state, token, action))
+
+        return entries
+
+
+class SLRGenerator(LR0Generator):
+    def _create_reduce_entries(self, states: set[LR0State]) -> set[Entry]:
+        """
+        Computes and returns the entries for reduce actions and the accept action.
+        """
+        entries: set[Entry] = set()
+
+        for state in states:
+            for item in state.items:
+                if item.after_dot == Token.eof():
+                    action = Action(item.rule, ActionType.ACCEPT)
+                    entries.add(Entry(state, Token.eof(), action))
+
+                if not item.dot_is_last():
+                    continue
+
+                action = Action(item.rule, ActionType.REDUCE)
+                for token in self._follow(item.rule.lhs):
+                    entries.add(Entry(state, token, action))
+
+        return entries

syntactes-0.1.0/src/syntactes/grammar.py

@@ -0,0 +1,22 @@
+from typing import Iterable
+
+from syntactes.rule import Rule
+from syntactes.token import Token
+
+
+class Grammar:
+    """
+    A grammar is a set of rules that describe a language.
+
+    The only valid 'words' of the language are the given tokens.
+    """
+
+    def __init__(
+        self, starting_rule: Rule, rules: Iterable[Rule], tokens: set[Token]
+    ) -> None:
+        """
+        `starting_rule` should also be included in `rules`.
+        """
+        self.starting_rule = starting_rule
+        self.rules = rules
+        self.tokens = tokens

syntactes-0.1.0/src/syntactes/rule.py

@@ -0,0 +1,31 @@
+from syntactes.token import Token
+
+
+class Rule:
+    """
+    Production rule. Describes the break-down of a non-terminal symbol to
+    other symbols.
+
+    LHS -> RHS1 RHS2...
+    """
+
+    def __init__(self, number: int, lhs: Token, *args: tuple[Token]) -> None:
+        self.number = number
+        self.lhs = lhs
+        self.rhs = args
+        self.rhs_len = len(args)
+
+    def __repr__(self) -> str:
+        return f"<Rule: {self}>"
+
+    def __str__(self) -> str:
+        return f"{self.lhs} -> " + " ".join(map(str, self.rhs))
+
+    def __hash__(self) -> int:
+        return hash((self.lhs, self.rhs))
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, Rule):
+            return False
+
+        return self.lhs == other.lhs and self.rhs == other.rhs

syntactes-0.1.0/src/syntactes/table.py

@@ -0,0 +1,130 @@
+from typing import Iterable, Optional, TypeAlias
+
+from syntactes._action import Action
+from syntactes._state import State
+from syntactes.grammar import Grammar
+from syntactes.token import Token
+
+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: State, 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 ParsingTable:
+    """
+    Table that contains all the transitions from state to state with a symbol.
+    """
+
+    def __init__(self, grammar: Grammar) -> None:
+        self.rows: dict[State, Row] = dict()
+        self._grammar = grammar
+
+    def get_actions(self, state: State, 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: State) -> 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 add_entry(self, entry: Entry) -> None:
+        """
+        Adds an entry to the parsing table.
+        """
+        self.rows.setdefault(entry.from_state, {}).setdefault(
+            entry.token, list()
+        ).append(entry.action)
+
+    @staticmethod
+    def from_entries(
+        entries: Iterable[Entry], tokens: Iterable[Token]
+    ) -> "ParsingTable":
+        """
+        Create a parsing table from the given entries.
+        """
+        table = ParsingTable(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()
+
+    def _rules_pretty_str(self) -> str:
+        rules = [str(i) + ". " + str(r) for i, r in enumerate(self._grammar.rules)]
+        rules_str = "\n".join(rules)
+        rules_str = "GRAMMAR RULES\n" + "-" * max(map(len, rules)) + "\n" + rules_str
+        rules_str += "\n" + "-" * max(map(len, rules))
+
+        return rules_str
+
+    def _table_pretty_str(self) -> str:
+        rows = []
+        tokens = sorted(self._grammar.tokens)
+        for number, row in sorted(
+            map(lambda tpl: (tpl[0].number, tpl[1]), self.rows.items())
+        ):
+            r = [str(number)]
+            for token in sorted(tokens):
+                actions = row.get(token, [])
+                if len(actions) >= 1:
+                    actions_str = ",".join(map(str, actions))
+                else:
+                    actions_str = "--"
+
+                r.append(actions_str)
+
+            rows.append(r)
+
+        table = "|     |  "
+        table += "   |  ".join(str(token) for token in tokens) + "  |\n"
+
+        header = self._header_str() + "\n" + "-" * len(table) + "\n"
+        table += "-" * len(table) + "\n"
+
+        for row in rows:
+            new_row = "|  " + "  |  ".join(row) + " |" + "\n"
+            table += new_row
+            table += "-" * len(new_row) + "\n"
+
+        return header + table
+
+    def _header_str(self) -> str:
+        return "LR0 PARSING TABLE"

syntactes-0.1.0/src/syntactes/token.py

@@ -0,0 +1,45 @@
+class Token:
+    """
+    A token of the grammar. Can be a terminal or non-terminal symbol.
+    """
+
+    def __init__(self, symbol: str, is_terminal: bool) -> None:
+        self.symbol = symbol
+        self.is_terminal = is_terminal
+
+    @staticmethod
+    def null() -> "Token":
+        """
+        Returns the NULL token.
+        """
+        return Token("ε", True)
+
+    @staticmethod
+    def eof() -> "Token":
+        """
+        Returns the EOF token.
+        """
+        return Token("$", True)
+
+    def __repr__(self) -> str:
+        return f"<Token: {self}>"
+
+    def __str__(self) -> str:
+        return self.symbol
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, Token):
+            return False
+
+        return self.symbol == other.symbol and self.is_terminal is other.is_terminal
+
+    def __lt__(self, other) -> bool:
+        if not isinstance(other, Token):
+            raise ValueError(
+                f"'<' not supported between instances of 'Token' and {type(other).__name__}"
+            )
+
+        return self.symbol < other.symbol

syntactes-0.1.0/src/syntactes.egg-info/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: syntactes
+Version: 0.1.0
+Summary: Parser generator
+Author-email: Maximos Nikiforakis <nikiforos@live.co.uk>
+License: MIT
+Project-URL: Homepage, https://github.com/Maxcode123/syntactes
+Project-URL: Issues, https://github.com/Maxcode123/syntactes/issues
+Keywords: parser,generator
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown

syntactes-0.1.0/src/syntactes.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/syntactes/__init__.py
+src/syntactes/_action.py
+src/syntactes/_item.py
+src/syntactes/_state.py
+src/syntactes/generator.py
+src/syntactes/grammar.py
+src/syntactes/rule.py
+src/syntactes/table.py
+src/syntactes/token.py
+src/syntactes.egg-info/PKG-INFO
+src/syntactes.egg-info/SOURCES.txt
+src/syntactes.egg-info/dependency_links.txt
+src/syntactes.egg-info/top_level.txt

syntactes-0.1.0/src/syntactes.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

syntactes-0.1.0/src/syntactes.egg-info/top_level.txt

@@ -0,0 +1 @@
+syntactes