ready

Readme.md

@@ -123,7 +123,7 @@ Verá la indicación **Some checks haven't completed yet**.
 
 ![](img/img8.png)
 
-Es posible que tenga que actualizar los cambios que se hayan hecho en el repositorio original, por ejemplo, si se han agregado nuevos tests. En este caso obtendrá el siguiente mensaje:
+Es posible que tenga que actualizar los cambios que se hayan hecho en el repositorio original, por ejemplo, si se han agregado nuevos tests. En este caso obtendrá el siguiente mensaje: 
 
 > **This branch is out-of-date with base branch**
 

doc/team.yml

@@ -1,10 +1,8 @@
 members:
-  - name: Nombre Apellido1 Apellido2
-    github: github_id
-    group: CXXX
-  - name: Nombre Apellido1 Apellido2
-    github: github_id
-    group: CXXX
-  - name: Nombre Apellido1 Apellido2
-    github: github_id
-    group: CXXX
+  - name: Alejandro Campos Matanzas
+    github: Alexx-4
+    group: C-411
+
+  - name: Darian Dominguez Alayón
+    github: Darian10
+    group: C-411

src/cmp/ast.py

@@ -0,0 +1,62 @@
+import cmp.visitor as visitor
+
+class Node:
+    def evaluate(self):
+        raise NotImplementedError()
+
+class AtomicNode(Node):
+    def __init__(self, lex):
+        self.lex = lex
+
+class UnaryNode(Node):
+    def __init__(self, node):
+        self.node = node
+
+    def evaluate(self):
+        value = self.node.evaluate()
+        return self.operate(value)
+
+    @staticmethod
+    def operate(value):
+        raise NotImplementedError()
+
+class BinaryNode(Node):
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+
+    def evaluate(self):
+        lvalue = self.left.evaluate()
+        rvalue = self.right.evaluate()
+        return self.operate(lvalue, rvalue)
+
+    @staticmethod
+    def operate(lvalue, rvalue):
+        raise NotImplementedError()
+
+def get_printer(AtomicNode=AtomicNode, UnaryNode=UnaryNode, BinaryNode=BinaryNode, ):
+
+    class PrintVisitor(object):
+        @visitor.on('node')
+        def visit(self, node, tabs):
+            pass
+
+        @visitor.when(UnaryNode)
+        def visit(self, node, tabs=0):
+            ans = '\t' * tabs + f'\\__<expr> {node.__class__.__name__}'
+            child = self.visit(node.node, tabs + 1)
+            return f'{ans}\n{child}'
+
+        @visitor.when(BinaryNode)
+        def visit(self, node, tabs=0):
+            ans = '\t' * tabs + f'\\__<expr> {node.__class__.__name__} <expr>'
+            left = self.visit(node.left, tabs + 1)
+            right = self.visit(node.right, tabs + 1)
+            return f'{ans}\n{left}\n{right}'
+
+        @visitor.when(AtomicNode)
+        def visit(self, node, tabs=0):
+            return '\t' * tabs + f'\\__ {node.__class__.__name__}: {node.lex}'
+
+    printer = PrintVisitor()
+    return (lambda ast: printer.visit(ast))

src/cmp/automata.py

@@ -0,0 +1,207 @@
+try:
+    import pydot
+except:
+    pass
+
+class State:
+    def __init__(self, state, final=False, formatter=lambda x: str(x), shape='circle'):
+        self.state = state
+        self.final = final
+        self.transitions = {}
+        self.epsilon_transitions = set()
+        self.tag = None
+        self.formatter = formatter
+        self.shape = shape
+
+    # The method name is set this way from compatibility issues.
+    def set_formatter(self, value, attr='formatter', visited=None):
+        if visited is None:
+            visited = set()
+        elif self in visited:
+            return
+
+        visited.add(self)
+        self.__setattr__(attr, value)
+        for destinations in self.transitions.values():
+            for node in destinations:
+                node.set_formatter(value, attr, visited)
+        for node in self.epsilon_transitions:
+            node.set_formatter(value, attr, visited)
+        return self
+
+    def has_transition(self, symbol):
+        return symbol in self.transitions
+
+    def add_transition(self, symbol, state):
+        try:
+            self.transitions[symbol].append(state)
+        except:
+            self.transitions[symbol] = [state]
+        return self
+
+    def add_epsilon_transition(self, state):
+        self.epsilon_transitions.add(state)
+        return self
+
+    def recognize(self, string):
+        states = self.epsilon_closure
+        for symbol in string:
+            states = self.move_by_state(symbol, *states)
+            states = self.epsilon_closure_by_state(*states)
+        return any(s.final for s in states)
+
+    def to_deterministic(self, formatter=lambda x: str(x)):
+        closure = self.epsilon_closure
+        start = State(tuple(closure), any(s.final for s in closure), formatter)
+
+        closures = [ closure ]
+        states = [ start ]
+        pending = [ start ]
+
+        while pending:
+            state = pending.pop()
+            symbols = { symbol for s in state.state for symbol in s.transitions }
+
+            for symbol in symbols:
+                move = self.move_by_state(symbol, *state.state)
+                closure = self.epsilon_closure_by_state(*move)
+
+                if closure not in closures:
+                    new_state = State(tuple(closure), any(s.final for s in closure), formatter)
+                    closures.append(closure)
+                    states.append(new_state)
+                    pending.append(new_state)
+                else:
+                    index = closures.index(closure)
+                    new_state = states[index]
+
+                state.add_transition(symbol, new_state)
+
+        return start
+
+    @staticmethod
+    def from_nfa(nfa, get_states=False):
+        states = []
+        for n in range(nfa.states):
+            state = State(n, n in nfa.finals)
+            states.append(state)
+
+        for (origin, symbol), destinations in nfa.map.items():
+            origin = states[origin]
+            origin[symbol] = [ states[d] for d in destinations ]
+
+        if get_states:
+            return states[nfa.start], states
+        return states[nfa.start]
+
+    @staticmethod
+    def move_by_state(symbol, *states):
+        return { s for state in states if state.has_transition(symbol) for s in state[symbol]}
+
+    @staticmethod
+    def epsilon_closure_by_state(*states):
+        closure = { state for state in states }
+
+        l = 0
+        while l != len(closure):
+            l = len(closure)
+            tmp = [s for s in closure]
+            for s in tmp:
+                for epsilon_state in s.epsilon_transitions:
+                        closure.add(epsilon_state)
+        return closure
+
+    @property
+    def epsilon_closure(self):
+        return self.epsilon_closure_by_state(self)
+
+    @property
+    def name(self):
+        return self.formatter(self.state)
+
+    def get(self, symbol):
+        target = self.transitions[symbol]
+        assert len(target) == 1
+        return target[0]
+
+    def __getitem__(self, symbol):
+        if symbol == '':
+            return self.epsilon_transitions
+        try:
+            return self.transitions[symbol]
+        except KeyError:
+            return None
+
+    def __setitem__(self, symbol, value):
+        if symbol == '':
+            self.epsilon_transitions = value
+        else:
+            self.transitions[symbol] = value
+
+    def __repr__(self):
+        return str(self)
+
+    def __str__(self):
+        return str(self.state)
+
+    def __hash__(self):
+        return hash(self.state)
+
+    def __iter__(self):
+        yield from self._visit()
+
+    def _visit(self, visited=None):
+        if visited is None:
+            visited = set()
+        elif self in visited:
+            return
+
+        visited.add(self)
+        yield self
+
+        for destinations in self.transitions.values():
+            for node in destinations:
+                yield from node._visit(visited)
+        for node in self.epsilon_transitions:
+            yield from node._visit(visited)
+
+    def graph(self):
+        G = pydot.Dot(rankdir='LR', margin=0.1)
+        G.add_node(pydot.Node('start', shape='plaintext', label='', width=0, height=0))
+
+        visited = set()
+        def visit(start):
+            ids = id(start)
+            if ids not in visited:
+                visited.add(ids)
+                G.add_node(pydot.Node(ids, label=start.name, shape=self.shape, style='bold' if start.final else ''))
+                for tran, destinations in start.transitions.items():
+                    for end in destinations:
+                        visit(end)
+                        G.add_edge(pydot.Edge(ids, id(end), label=tran, labeldistance=2))
+                for end in start.epsilon_transitions:
+                    visit(end)
+                    G.add_edge(pydot.Edge(ids, id(end), label='ε', labeldistance=2))
+
+        visit(self)
+        G.add_edge(pydot.Edge('start', id(self), label='', style='dashed'))
+
+        return G
+
+    def _repr_svg_(self):
+        try:
+            return self.graph().create_svg().decode('utf8')
+        except:
+            pass
+
+    def write_to(self, fname):
+        return self.graph().write_svg(fname)
+
+def multiline_formatter(state):
+    return '\n'.join(str(item) for item in state)
+
+def lr0_formatter(state):
+    try:
+        return '\n'.join(str(item)[:-4] for item in state)
+    except TypeError:
+        return str(state)[:-4]