Add part 17

Author: AlimU11

part 17 - call stack and activation records/lesson/ARNode.py

@@ -0,0 +1,12 @@
+from ActivationRecord import ActivationRecord
+from ScopedSymbolTable import ScopedSymbolTable
+
+
+class ARNode:
+    def __init__(self, scope):
+        self.scope: ScopedSymbolTable = scope
+        self.ar_records: list[ActivationRecord] = []
+        self.children: list[ARNode] = []
+
+    def __str__(self):
+        return f'{self.scope.scope_name} {self.scope.scope_level} <- {self.scope.enclosing_scope.scope_name if self.scope.enclosing_scope else None}'

part 17 - call stack and activation records/lesson/ARTree.py

@@ -0,0 +1,86 @@
+from ActivationRecord import ActivationRecord
+from ARNode import ARNode
+
+
+class ARTree:
+    def __init__(self):
+        self.root: ARNode
+
+    def build_tree(self, scopes):
+        """
+        Builds the tree from the list of scopes. The first scope in the list is
+        built-in scope and the root of the tree. Its only child is second scope in the list
+        - the global scope. Other scopes are children or ancestors of the global scope. It
+        is guaranteed that that each scope is unique and that at least built-in and global
+        scopes are present in the list.
+        """
+        self.root = ARNode(scopes[0])
+
+        for scope in scopes[1:]:
+            node = ARNode(scope)
+            parent = self._find_parent(scope, self.root)
+            parent.children.append(node)
+
+    def _find_parent(self, scope, root: ARNode) -> ARNode:
+        """
+        Finds the parent of the given scope. It is guaranteed that the scope has a parent.
+        """
+
+        if scope.enclosing_scope == root.scope and scope.scope_level == root.scope.scope_level + 1:
+            return root
+        else:
+            for child in root.children:
+                node = self._find_parent(scope, child)
+                if node:
+                    return node
+
+        return ARNode(None)
+
+    def _find_node(self, name: str, level: int, root: ARNode) -> ARNode:
+        """
+        Finds the node with the given name and level. It is guaranteed that the node exists.
+        """
+        if root.scope.scope_name == name and root.scope.scope_level == level:
+            return root
+        else:
+            for child in root.children:
+                node = self._find_node(name, level, child)
+                if node:
+                    return node
+
+        return ARNode(None)
+
+    def push(self, AR: ActivationRecord) -> None:
+        node = self._find_node(AR.scope_name, AR.nesting_level, self.root)
+        node.ar_records.append(AR)
+
+    def __str__(self):
+        return '\n'.join([i.__str__() for i in self.bf_traverse(self.root)])
+
+    def preorder_traverse(self, root: ARNode) -> list[ARNode]:
+        """
+        Performs a pre-order traversal of the tree.
+        Returns a list of nodes in the order they were visited.
+        """
+        nodes = [root]
+
+        for child in root.children:
+            nodes += self.preorder_traverse(child)
+
+        return nodes
+
+    def bf_traverse(self, root: ARNode) -> list[ARNode]:
+        """
+        Performs a breadth-first traversal of the tree.
+        Returns a list of nodes in the order they were visited.
+        """
+        nodes = [root]
+        queue = [root]
+
+        while queue:
+            node = queue.pop(0)
+            for child in node.children:
+                nodes.append(child)
+                queue.append(child)
+
+        return nodes

part 17 - call stack and activation records/lesson/ARType.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+
+class ARType(Enum):
+    PROGRAM = 'PROGRAM'

part 17 - call stack and activation records/lesson/AST.py

@@ -0,0 +1,91 @@
+class AST(object):
+    pass
+
+
+class BinOp(AST):
+    def __init__(self, left, op, right):
+        self.left = left
+        self.token = self.op = op
+        self.right = right
+
+
+class Num(AST):
+    def __init__(self, token):
+        self.token = token
+        self.value = token.value
+
+
+class UnaryOp(AST):
+    def __init__(self, op, expr):
+        self.token = self.op = op
+        self.expr = expr
+
+
+class Compound(AST):
+    """Represents a 'BEGIN ... END' block"""
+
+    def __init__(self):
+        self.children = []
+
+
+class Assign(AST):
+    def __init__(self, left, op, right):
+        self.left = left
+        self.token = self.op = op
+        self.right = right
+
+
+class Var(AST):
+    """The Var node is constructed out of ID token."""
+
+    def __init__(self, token):
+        self.token = token
+        self.value = token.value
+
+
+class NoOp(AST):
+    pass
+
+
+class Program(AST):
+    def __init__(self, name, block):
+        self.name = name
+        self.block = block
+
+
+class Block(AST):
+    def __init__(self, declarations, compound_statement):
+        self.declarations = declarations
+        self.compound_statement = compound_statement
+
+
+class VarDecl(AST):
+    def __init__(self, var_node, type_node):
+        self.var_node = var_node
+        self.type_node = type_node
+
+
+class Type(AST):
+    def __init__(self, token):
+        self.token = token
+        self.value = token.value
+
+
+class ProcedureDecl(AST):
+    def __init__(self, proc_name, params, block_node):
+        self.proc_name = proc_name
+        self.params = params
+        self.block_node = block_node
+
+
+class Param(AST):
+    def __init__(self, var_node, type_node):
+        self.var_node = var_node
+        self.type_node = type_node
+
+
+class ProcedureCall(AST):
+    def __init__(self, proc_name, actual_params, token):
+        self.proc_name = proc_name
+        self.actual_params = actual_params
+        self.token = token

part 17 - call stack and activation records/lesson/ActivationRecord.py

@@ -0,0 +1,35 @@
+class ActivationRecord:
+    def __init__(self, name, scope_name, type, nesting_level, execution_order):
+        self.name = name
+        self.scope_name = scope_name
+        self.type = type
+        self.nesting_level = nesting_level
+        self.exdecution_order = execution_order
+        self.members = {}
+
+    def __setitem__(self, key, value):
+        self.members[key] = value
+
+    def __getitem__(self, key):
+        return self.members[key]
+
+    def get(self, key):
+        return self.members.get(key)
+
+    def __str__(self):
+        lines = [
+            '{level}: {type} {name} (execution order: {execution_order})'.format(
+                level=self.nesting_level,
+                type=self.type.name,
+                name=self.name,
+                execution_order=self.exdecution_order,
+            ),
+        ]
+        for name, val in self.members.items():
+            lines.append(f'   {name:<20}: {val}')
+
+        s = '\n'.join(lines)
+        return s
+
+    def __repr__(self):
+        return self.__str__()

part 17 - call stack and activation records/lesson/CallStack.py

@@ -0,0 +1,20 @@
+class CallStack:
+    def __init__(self):
+        self._records = []
+
+    def push(self, ar):
+        self._records.append(ar)
+
+    def pop(self):
+        return self._records.pop()
+
+    def peek(self):
+        return self._records[-1]
+
+    def __str__(self):
+        s = '\n'.join(repr(ar) for ar in reversed(self._records))
+        s = f'CALL STACK\n{s}\n'
+        return s
+
+    def __repr__(self):
+        return self.__str__()

part 17 - call stack and activation records/lesson/Error.py

@@ -0,0 +1,30 @@
+from enum import Enum
+
+
+class ErrorCode(Enum):
+    UNEXPECTED_TOKEN = 'Unexpected token'
+    ID_NOT_FOUND = 'Identifier not found'
+    DUPLICATE_ID = 'Duplicate id found'
+    WRONG_ARGUMENTS_NUMBER = 'Wrong number of arguments'
+
+
+class Error(Exception):
+    def __init__(self, error_code=None, token=None, message=None):
+        self.error_code = error_code
+        self.token = token
+        self.message = f'{self.__class__.__name__}: {message}'
+
+    def __str__(self):
+        return self.message
+
+
+class LexerError(Error):
+    pass
+
+
+class ParserError(Error):
+    pass
+
+
+class SemanticError(Error):
+    pass

part 17 - call stack and activation records/lesson/Interpreter.py

@@ -0,0 +1,106 @@
+from ActivationRecord import ActivationRecord
+from ARTree import ARTree
+from ARType import ARType
+from CallStack import CallStack
+from NodeVisitor import NodeVisitor
+from SemanticAnalyzer import SemanticAnalyzer
+from TokenType import TokenType
+
+
+class Interpreter(NodeVisitor):
+    def __init__(self, text):
+        self.semantic_analyzer = SemanticAnalyzer(text)
+        self.call_stack = CallStack()
+        self.ar_tree = ARTree()
+        self.global_execution_order = 0
+
+    def visit_Program(self, node):
+        program_name = node.name
+
+        AR = ActivationRecord(
+            name=program_name,
+            scope_name='global',
+            type=ARType.PROGRAM,
+            nesting_level=1,
+            execution_order=self.global_execution_order,
+        )
+
+        self.call_stack.push(AR)
+        self.global_execution_order += 1
+
+        self.visit(node.block)
+
+        self.ar_tree.push(self.call_stack.pop())
+
+    def visit_Block(self, node):
+        for declaration in node.declarations:
+            self.visit(declaration)
+        self.visit(node.compound_statement)
+
+    def visit_VarDecl(self, node):
+        # Do nothing
+        pass
+
+    def visit_Type(self, node):
+        # Do nothing
+        pass
+
+    def visit_BinOp(self, node):
+        if node.op.type == TokenType.PLUS:
+            return self.visit(node.left) + self.visit(node.right)
+        elif node.op.type == TokenType.MINUS:
+            return self.visit(node.left) - self.visit(node.right)
+        elif node.op.type == TokenType.MUL:
+            return self.visit(node.left) * self.visit(node.right)
+        elif node.op.type == TokenType.INTEGER_DIV:
+            return self.visit(node.left) // self.visit(node.right)
+        elif node.op.type == TokenType.FLOAT_DIV:
+            return float(self.visit(node.left)) / float(self.visit(node.right))
+
+    def visit_Num(self, node):
+        return node.value
+
+    def visit_UnaryOp(self, node):
+        op = node.op.type
+        if op == TokenType.PLUS:
+            return +self.visit(node.expr)
+        elif op == TokenType.MINUS:
+            return -self.visit(node.expr)
+
+    def visit_Compound(self, node):
+        for child in node.children:
+            self.visit(child)
+
+    def visit_Assign(self, node):
+        var_name = node.left.value
+        var_value = self.visit(node.right)
+
+        AR = self.call_stack.peek()
+        AR[var_name] = var_value
+
+    def visit_Var(self, node):
+        var_name = node.value
+
+        AR = self.call_stack.peek()
+        var_value = AR.get(var_name)
+
+        return var_value
+
+    def visit_NoOp(self, node):
+        pass
+
+    def visit_ProcedureDecl(self, node):
+        pass
+
+    def visit_ProcedureCall(self, node):
+        pass
+
+    def interpret(self):
+        tree = self.semantic_analyzer.analyze()
+
+        if tree is None:
+            return ''
+
+        self.ar_tree.build_tree(self.semantic_analyzer.scopes)
+
+        return self.visit(tree)