Add built-in procedure WRITELN

Author: AlimU11

README.md

@@ -16,11 +16,39 @@ A simple Pascal interpreter based on [Let's Build a Simple Interpreter](https://
 - Additionally implemented:
   - Procedures can access non-local variables
   - UI with following output:
-    - Error messages
+    - Standard and error output
     - Table with scopes
     - Activation records for each scope
 
 ![img.png](src/img.png)
+<details>
+<summary>Sample program</summary>
+<br>
+<pre>
+program Main;
+
+procedure Alpha(a : integer; b : integer); { 4, 2 / 1, 3 }
+var x : integer;
+
+   procedure Beta(a : integer; c : integer); { 12, 2 / 8, 3 }
+   var x : integer;
+   begin
+      x := a * 10 + b * 2 + c; { 66 / 49 }
+      writeln(a);
+      writeln(x);
+   end;
+
+begin
+  x := (a + b ) * 2; { 12 / 8 }
+  Beta(x, b);
+end;
+
+begin { Main }
+  Alpha(2 + 2, 2);
+  Alpha(1, 3);
+end.  { Main }
+</pre>
+</details>
 
 ## Grammar
 

base/Interpreter.py

@@ -15,6 +15,7 @@ def __init__(self, text):
         self.call_stack = CallStack()
         self.ar_tree = ARTree()
         self.global_execution_order = 0
+        self.stdout = []
 
     def error(self, error_code, token):
         raise InterpreterError(error_code, token, message=f'{error_code.value} -> {token}')
@@ -101,6 +102,16 @@ def visit_ProcedureDecl(self, node):
     def visit_ProcedureCall(self, node):
         proc_name = node.proc_name
 
+        if proc_name == 'WRITELN':
+            out = ''
+
+            for param in node.actual_params:
+                out += str(self.visit(param))
+
+            self.stdout.append(out)
+
+            return
+
         AR = ActivationRecord(
             name=proc_name,
             scope_name=proc_name,

base/Parser.py

@@ -16,6 +16,7 @@
 )
 from base.Error import ErrorCode, ParserError
 from base.Lexer import Lexer
+from base.Token import Token
 from base.TokenType import TokenType
 
 
@@ -194,11 +195,10 @@ def statement(self):
                   | assignment_statement
                   | empty
         """
-
         if self.current_token.type == TokenType.BEGIN:
             node = self.compound_statement()
 
-        elif self.current_token.type == TokenType.ID:
+        elif self.current_token.type == TokenType.ID or Token.RESERVED_PROCEDURES.get(self.current_token.value):
 
             if self.lexer.current_char == '(':
                 node = self.proccall_statement()
@@ -226,7 +226,12 @@ def proccall_statement(self):
         token = self.current_token
 
         proc_name = self.current_token.value
-        self.eat(TokenType.ID)
+
+        if token.type == TokenType.ID:
+            self.eat(TokenType.ID)
+        elif Token.RESERVED_PROCEDURES.get(token.value):
+            self.eat(Token.RESERVED_PROCEDURES.get(token.value))
+
         self.eat(TokenType.LPAREN)
         actual_params = []
         if self.current_token.type != TokenType.RPAREN:

base/ScopedSymbolTable.py

@@ -1,4 +1,4 @@
-from base.Symbol import BuiltinTypeSymbol
+from base.Symbol import BuiltInProcedureSymbol, BuiltinTypeSymbol
 
 
 class ScopedSymbolTable:
@@ -11,6 +11,7 @@ def __init__(self, scope_name, scope_level, enclosing_scope=None):
     def _init_builtins(self):
         self.insert(BuiltinTypeSymbol('INTEGER'))
         self.insert(BuiltinTypeSymbol('REAL'))
+        self.insert(BuiltInProcedureSymbol('WRITELN'))
 
     def __str__(self):
         return self.scope_name

base/SemanticAnalyzer.py

@@ -2,7 +2,7 @@
 from base.NodeVisitor import NodeVisitor
 from base.Parser import Parser
 from base.ScopedSymbolTable import ScopedSymbolTable
-from base.Symbol import ProcedureSymbol, Symbol, VarSymbol
+from base.Symbol import BuiltInProcedureSymbol, ProcedureSymbol, Symbol, VarSymbol
 
 
 class SemanticAnalyzer(NodeVisitor):
@@ -125,11 +125,12 @@ def visit_ProcedureCall(self, node):
                 token=node.token,
             )
 
-        if len(node.actual_params) != len(proc_symbol.formal_params):
-            self.error(
-                error_code=ErrorCode.WRONG_ARGUMENTS_NUMBER,
-                token=node.token,
-            )
+        if not isinstance(proc_symbol, BuiltInProcedureSymbol):
+            if len(node.actual_params) != len(proc_symbol.formal_params):
+                self.error(
+                    error_code=ErrorCode.WRONG_ARGUMENTS_NUMBER,
+                    token=node.token,
+                )
 
         for param_node in node.actual_params:
             self.visit(param_node)

base/Symbol.py

@@ -55,3 +55,18 @@ def __str__(self):
 
     def __repr__(self):
         return self.__str__()
+
+
+class BuiltInProcedureSymbol(ProcedureSymbol):
+    def __init__(self, name):
+        super().__init__(name)
+
+    def __str__(self):
+        return '<{class_name}(name={name}, parameters={params})>'.format(
+            class_name=self.__class__.__name__,
+            name=self.name,
+            params=self.formal_params,
+        )
+
+    def __repr__(self):
+        return self.__str__()

base/Token.py

@@ -23,8 +23,16 @@ def __repr__(self):
     def _build_reserved_keywords():
         tokens = list(TokenType)
         start_idx = tokens.index(TokenType.PROGRAM)
-        end_idx = tokens.index(TokenType.END)
+        end_idx = tokens.index(TokenType.WRITELN)
+
+        return {token.value: token for token in tokens[start_idx : end_idx + 1]}
+
+    def _build_reserved_procedures():
+        tokens = list(TokenType)
+        start_idx = tokens.index(TokenType.WRITELN)
+        end_idx = tokens.index(TokenType.WRITELN)
 
         return {token.value: token for token in tokens[start_idx : end_idx + 1]}
 
     RESERVED_KEYWORDS = _build_reserved_keywords()
+    RESERVED_PROCEDURES = _build_reserved_procedures()

base/TokenType.py

@@ -15,7 +15,10 @@ class TokenType(Enum):
     COMMA = ','
 
     # reserved keywords
+    # it's important to have PROGRAM as the first keyword as it's affect
+    # building RESERVED_KEYWORDS dictionary
     PROGRAM = 'PROGRAM'
+
     INTEGER = 'INTEGER'
     REAL = 'REAL'
     INTEGER_DIV = 'DIV'
@@ -24,6 +27,9 @@ class TokenType(Enum):
     BEGIN = 'BEGIN'
     END = 'END'
 
+    # reserved procedures
+    WRITELN = 'WRITELN'
+
     # misc
     ID = 'ID'
     INTEGER_CONST = 'INTEGER_CONST'

main.py

@@ -98,7 +98,11 @@ def interpret(self):
 
                 self.ui.scopeComboBox.addItem(node.scope.scope_name)
 
+            for out in self.interpreter.stdout:
+                self.ui.output.append(out)
+
         except Exception as e:
+
             self.ui.output.setText(str(e))
             self.ui.output.setStyleSheet('color: red;')