Add part 18

Author: AlimU11

part 14 - nested scopes/lesson/src/grammar.ebnf

@@ -9,7 +9,7 @@
 # Declaration
 
 <declarations> ::= <VAR> { <variable_declaration> <SEMI> }+
-                | { <PROCEDURE> <ID> {LPAREN <formal_parameter_list> RPAREN}* <SEMI> <block> <SEMI> }* # TODO: check grammar
+                | { <PROCEDURE> <ID> {LPAREN <formal_parameter_list> RPAREN}* <SEMI> <block> <SEMI> }*
                 | <empty>
 
 <variable_declaration> ::= <ID> { <COMMA> <ID> }* <COLON> <type_spec>

part 16 - recognizing procedure calls/practice/README.md

@@ -34,7 +34,7 @@
 
 <assignment_statement> ::= <variable> <ASSIGN> <expression>
 
-<procedure_call_statement> ::= <ID> <LPAREN> [ <expression> { <COMMA> <expression> }* ] <RPAREN> # TODO
+<procedure_call_statement> ::= <ID> <LPAREN> [ <expression> { <COMMA> <expression> }* ] <RPAREN>
 
 <empty> ::= ''
 

part 17 - call stack and activation records/lesson/README.md

@@ -1,4 +1,4 @@
-# Part 16 - Practice
+# Part 17 - Practice
 
 ## Grammar
 
@@ -34,7 +34,7 @@
 
 <assignment_statement> ::= <variable> <ASSIGN> <expression>
 
-<procedure_call_statement> ::= <ID> <LPAREN> [ <expression> { <COMMA> <expression> }* ] <RPAREN> # TODO
+<procedure_call_statement> ::= <ID> <LPAREN> [ <expression> { <COMMA> <expression> }* ] <RPAREN>
 
 <empty> ::= ''
 
@@ -176,4 +176,4 @@ end.  { Main }
 
 ## Reference
 
-https://ruslanspivak.com/lsbasi-part16/
+https://ruslanspivak.com/lsbasi-part17/

part 17 - call stack and activation records/lesson/tmp.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 18 - executing procedure calls/lesson/ARNode.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 18 - executing procedure calls/lesson/ARTree.py

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

part 18 - executing procedure calls/lesson/ARType.py

@@ -0,0 +1,92 @@
+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
+        self.proc_symbol = None

part 18 - executing procedure calls/lesson/AST.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 18 - executing procedure calls/lesson/ActivationRecord.py

@@ -0,0 +1,27 @@
+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 __len__(self):
+        return len(self._records)
+
+    @property
+    def size(self):
+        return self.__len__()
+
+    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__()