def compute_closure(I, G):
rules_ = G.rules
J = set(I)
closure = set(I)
fixpoint = False
while not fixpoint:
print('fixpoint not reached')
fixpoint = True
J = closure.copy()
for item in J:
print('item : ')
print(item)
if not item.complete:
suff = item.suffix
for rule in rules_:
print('rule : ')
print(rule)
head = rule.head
if head == suff[0]:
additem = LR0Item((
rule,
0,
))
if additem not in closure:
closure.add(additem)
print('* added *')
fixpoint = False
return closure
def compute_items_1(G, S):
FRule = G.rules[0]
dollar = NT("$")
FItem = LR1Item(LR0Item((
FRule,
0,
)), dollar)
C = [(compute_closure_1([FItem], G))]
States = dict()
Graph = dict()
while C:
print('fixpoint not reached : Items built : ')
print(C)
I = C.pop()
Table = dict()
# for X in G.symbols:
for X in S:
transition = compute_transition_1(I, X, G)
print(transition)
if len(transition) > 0:
print('will be added')
Table.update({X: transition})
if transition not in C: C.append(transition)
print(' State added, States :')
print(C)
Graph.update({frozenset(I): Table})
return Graph
def closure(self, items):
done = set()
clos = set()
todo = list(items)
while todo:
it = todo.pop()
#print("item"," ".join(map(str,it)))
clos.add(it)
if it.complete:
continue
nxt = it.next
#print("Next is "+str(nxt))
if nxt.is_T :
#if (nxt,it.token) in done:
continue
done.add((nxt,it.token))
first= self.grammar.first(it.suffix[1:]+(it.token,))
# print("FIRST("," ".join(map(str,it.suffix[1:]+(it.token,))),")")
# for f in first:
# print(f)
for r in self.grammar.rules:
if r.head is nxt:
for b in first:
it = LR1Item((LR0Item((r,0)),b))
if it not in clos:
todo.append(it)
return frozenset(clos)
def __init__(self, gram):
self._grammar = gram
self._begin = self.closure([LR1Item((LR0Item((gram.axiom_rule,0,)),EOF))])
self._graph = None
self._index = None
self._rindex = None
self._table = None
self._states = None
self._sem = None
def transition(self,I,X):
J=set()
for item in I :
rule_=item.rule
index=item.index
if not item.lr0.complete:
if X==item.suffix[0]:
shift=LR1Item((LR0Item((rule_,index+1,)),item.token,))
J.add(shift)
#print "CLOSURE:",map(str,J)
return self.closure(J)
def compute_transition(I, X, G):
J = set()
for item in I:
rule_ = item.rule
index = item.index
if not item.complete:
if X == item.suffix[0]:
shift = LR0Item((
rule_,
index + 1,
))
J.add(shift)
return compute_closure(J, G)
def transition(self, I, X):
J = set()
for item in I:
rule_ = item.rule
index = item.index
if not item.complete:
if X == item.suffix[0]:
shift = LR0Item((
rule_,
index + 1,
))
J.add(shift)
return self.closure(J)
def closure(self, items):
done = set()
clos = set()
todo = list(items)
while todo:
it = todo.pop()
clos.add(it)
if it.complete:
continue
nxt = it.next
if nxt.is_T or nxt in done:
continue
done.add(nxt)
for r in self.grammar.rules:
if r.head is nxt:
it = LR0Item((r, 0))
if it not in clos:
todo.append(it)
return frozenset(clos)
def __init__(self, gram):
self._grammar = gram
self._begin = self.closure([LR0Item((gram.axiom_rule, 0))])
self._graph = None
self._index = None
self._rindex = None