added support of function call before declaration (0.5h)

sample_input/func_very_simple.swift

@@ -1,6 +1,6 @@
 var some_var: Int = 555;
+var glob: Int = some_function(some_var);
 func some_function(a: Int) -> Int {
     a += 111;
     return a;
 }
-var glob: Int = some_function(some_var);

src/pl0_code_generator/pl0.py

@@ -30,6 +30,7 @@ def generate_instructions(self):
         self.generate_code(sub_tree=self.clear_tree(self.ast.iter_prepostorder()), symbol_table=self.symbol_table)
         # end of code
         self.generate_instruction(self.inst(Inst.ret), 0, 0)
+        self.correct_func_call_jmp()
 
     # [JT] level stores the current scope, 0 for global, <identifier> for function scope
     # level_numerical current indentation
@@ -200,11 +201,6 @@ def gen_function_signature(self, sub_tree, index, symbol_table=None, level=0):
             self.generate_instruction(self.inst(Inst.lod), level, -i)
         self.generate_code(sub_tree=sub_sub_tree, level=level,
                            symbol_table=symbol_table)
-        '''
-        for local_scope in locals:
-            self.generate_code(sub_tree=sub_sub_tree, level=level,
-                           symbol_table=local_scope)
-        '''
         index += len(sub_sub_tree)
         self.generate_instruction(self.inst(Inst.sto), level, - 1 - (len(symbol_table[self.curr_func_name].params)))
         self.generate_instruction(self.inst(Inst.ret), 0, 0)
@@ -258,7 +254,7 @@ def gen_condition(self, condition, index, level, symbol_table=None, make_negatio
                                                  make_negation=True)
             return True, index, level
         else:
-            if len(condition.children) > 1 and\
+            if len(condition.children) > 1 and \
                     condition.children[1].get_leaf_names()[0] in self.cond_expressions.keys():
                 index, level = self.generate_code_again(index, level, symbol_table, condition.children[0])
                 index, level = self.generate_code_again(index, level, symbol_table, condition.children[2])
@@ -327,7 +323,7 @@ def gen_func_call(self, sub_tree, symbol_table=None, level=0):
                     args_len += 1
                 i += len(sub_sub_tree)
                 func_len = i
-                self.generate_instruction(self.inst(Inst.cal), level, symbol_table[f_name].address)
+                self.generate_instruction(self.inst(Inst.cal), level, symbol_table[f_name].id)
                 if args_len > 0:
                     self.generate_instruction(self.inst(Inst.int), 0, -args_len)
             i += 1
@@ -429,7 +425,6 @@ def gen_if_else(self, sub_tree, index, level, symbol_table=None):
             block2 = sub_tree[index].children[2]
         if "condition" in condition.name:
             _, index, level = self.gen_condition(condition, index, level, symbol_table=symbol_table)
-
             x = id("x" + str(level))
             self.correct_jmc_for_logical_condition(x)
             index += len(self.clear_tree(condition.iter_prepostorder()))
@@ -454,8 +449,6 @@ def gen_if_else(self, sub_tree, index, level, symbol_table=None):
                 y = id("y" + str(level))
                 self.generate_instruction(self.inst(Inst.jmp), 0, y)
                 self.generate_code(sub_tree=sub_sub_tree, level=level + 1, symbol_table=symbol_table)
-                #                self.generate_code(sub_tree=sub_sub_tree, level=level, symbol_table=symbol_table)
-
                 index += len(sub_sub_tree)
                 for i in self.code:
                     if i[2] == y:
@@ -477,3 +470,17 @@ def generate_code_again(self, index, level, symbol_table, sub_tree):
         self.generate_code(sub_tree=sub_sub_tree, level=level, symbol_table=symbol_table)
         index += len(sub_sub_tree)
         return index, level
+
+    def correct_func_call_jmp(self):
+        """
+        support of function call before declaration
+        """
+        functions_dict = {}
+        self.symbol_table.pop("_scopes")
+        for key in self.symbol_table:
+            if self.symbol_table[key].type == "func":
+                functions_dict[self.symbol_table[key].id] = self.symbol_table[key].address
+
+        for i in self.code:
+            if i[2] in functions_dict.keys():
+                i[2] = functions_dict[i[2]]

src/pl0_code_generator/pl0_const.py

@@ -2,8 +2,6 @@
 #  author: Daniel Schnurpfeil
 #
 
-from enum import Enum
-
 
 # It's a class that holds the constants used by the PL/0 compiler
 class Pl0Const:

test/test_main.py

@@ -400,22 +400,22 @@ def test_func_very_simple(self):
 1 INT 0 1
 2 LIT 0 555
 3 STO 0 3
-4 JMP 0 14
-5 INT 0 3
-6 LOD 0 -1
-7 LIT 0 111
-8 LOD 0 3
-9 OPR 0 2
-10 STO 0 3
-11 LOD 0 3
-12 STO 0 -2
-13 RET 0 0
-14 INT 0 1
-15 INT 0 1
-16 LOD 0 3
-17 CAL 0 5
-18 INT 0 -1
-19 STO 0 5
+4 INT 0 1
+5 INT 0 1
+6 LOD 0 3
+7 CAL 0 11
+8 INT 0 -1
+9 STO 0 4
+10 JMP 0 20
+11 INT 0 3
+12 LOD 0 -1
+13 LIT 0 111
+14 LOD 0 3
+15 OPR 0 2
+16 STO 0 3
+17 LOD 0 3
+18 STO 0 -2
+19 RET 0 0
 20 RET 0 0
 """, code, "func_very_simple")