def __from_dictionary(source: dict, rule_extractor):
non_terminals = [
NonTerminal(item) for item in source.get('non-terminals')
]
terminals = [Terminal(item) for item in source.get('terminals')]
rules = [rule_extractor(rule) for rule in source.get('rules')]
start = NonTerminal(source.get('start'))
return ContextFreeGrammar(non_terminals, terminals, rules, start)
def from_string(string: str):
result = string.replace(' ', '').split('->')
visited, left = result[1].split('.')
return ParserItem(
NonTerminal(result[0]),
ParserPosition([Symbol(x) for x in visited],
[Symbol(x) for x in left]))
def __init__(self, grammar: ContextFreeGrammar):
self.__grammar = grammar
extended = self.__grammar.extend()
item = ParserItem.item_for(extended.rules_of(NonTerminal("E"))[0])
items = Closure(item, extended).closure()
self.__start = State(items, self.__grammar)
self.__transitions = []
self.__states = [self.__start]
self.__build(self.__start, self.__transitions, self.__states)
def test_when_generating_closure_expect_valid_items(self):
# declarations:
extended = self.grammar.extend()
item = ParserItem.item_for(extended.rules_of(NonTerminal("E"))[0])
# when:
items = Closure(item, extended).closure()
# then:
self.assertEqual(items, [
ParserItem.from_string('E -> . S'),
ParserItem.from_string('S -> . a A')
])
def test_when_generating_state_finite_automaton_expect_valid_transitions(
self):
# when:
transitions = StateFiniteAutomaton(self.grammar).transitions
# then:
self.assertEqual(len(transitions), 8)
self.assertEqual(
(transitions[0].source.items, transitions[0].destination.items,
transitions[0].symbol), ([
ParserItem.from_string('E -> . S'),
ParserItem.from_string('S -> .aA')
], [ParserItem.from_string('E -> S.')], NonTerminal("S")))
def test_when_is_going_to_next_state_expect_valid_next_state(self):
# declarations:
extended = self.grammar.extend()
item = ParserItem.item_for(extended.rules_of(NonTerminal("E"))[0])
items = Closure(item, extended).closure()
state = State(items, self.grammar)
# when
actual = state.go_to(Symbol("a"))
# then:
self.assertEqual(actual.items, [
ParserItem.from_string('S -> a . A'),
ParserItem.from_string('A -> . b A'),
ParserItem.from_string('A -> . c')
])
def extend(self):
return ContextFreeGrammar(
self._non_terminals + [NonTerminal("E")], self._alphabet,
self._rules + [Rule(NonTerminal("E"), [self._start])],
NonTerminal("E"))
import json
import sys
from parsing.domain.context_free_grammar import ContextFreeGrammar
from parsing.domain.non_terminal import NonTerminal
from parsing.domain.rule import Rule
from parsing.domain.symbol import Symbol
from parsing.domain.terminal import Terminal
if __name__ == '__main__':
with open(sys.argv[1], "r") as file:
given = json.loads(file.read())
non_terminals = [NonTerminal(x) for x in given["non_terminals"]]
alphabet = [Terminal(x) for x in given["alphabet"]]
rules = [Rule(NonTerminal(x), [Symbol(y)])
for x, y in [tuple(rule.split(" -> "))
for rule in given["rules"]]]
start = NonTerminal(given["start"])
grammar = ContextFreeGrammar(non_terminals, alphabet, rules, start)
print(grammar.extend())
def from_complex_string(string: str):
result = string.split(' -> ')
return Rule(
NonTerminal(result[0].replace(' ', '')),
[Symbol(x) for x in Rule.__get_symbols_from_string(result)])
def from_string(string: str):
result = string.replace(' ', '').split('->')
return Rule(NonTerminal(result[0]), [Symbol(x) for x in result[1]])