that's enough, i dont work on this shit anymore

Author: EAliakbar

MinijavaPrintListener.py

@@ -21,13 +21,15 @@ class MiniJavaPrintListener(MinijavaListener):
     def __init__(self, symbolTable):
         super().__init__()
         self.currentClass = ""
-        self.currentMethodType = ""
+        self.currentMethod = ""
         self.lastExpressionType = ""
         self.codeStore = {}
         self.code = ""
         self.isInitialized = False
 
         self.symbolTable = symbolTable
+        self.lables = []
+        self.lableCounter = 0
 
         self.block_number = 0
         self.variables = {}
@@ -40,17 +42,49 @@ def get_bytecode(self):
     def get_representation(s_type):
         if s_type == 'int':
             return 'I'
-        if s_type == 'boolean':
+        elif s_type == 'boolean':
             return 'Z'
+        else:
+            print("type UNKNOWN", s_type)
+
+    def get_new_lable(self):
+        lable = 'LABLE_' + str(self.lableCounter)
+        self.lableCounter = self.lableCounter + 1
+        self.lables.append(lable)
+        return lable
+
+    def get_last_lable(self):
+        return self.lables[-1]
+
+    def remove_last_lable(self):
+        self.lables = self.lables[:-1]
 
     @staticmethod
     def get_return_by_type(s_type):
         #todo implement array
         if s_type == 'int':
             return 'ireturn'
-        if s_type == 'boolean':
+        elif s_type == 'boolean':
             return 'ireturn'
 
+
+    def get_method_type(self, method_name):
+        prop = self.symbolTable[self.currentClass][method_name]
+        return_type = prop['return_type']
+        return return_type
+
+    def get_method_inp_type(self, method_name, lookup_class=None):
+        if lookup_class is None:
+            lookup_class = self.currentClass
+        print(lookup_class, "PPPPPPPPP")
+        print(self.symbolTable[lookup_class])
+        prop = self.symbolTable[lookup_class][method_name]
+        inputs = prop["inputs"]
+        str_types = ""
+        for inp in inputs:
+            str_types += self.get_representation(inp[0]) + ','
+        return str_types[:-1]
+
     def enterMainClass(self, ctx:MinijavaParser.MainClassContext):
         self.currentClass = ctx.getChild(1).getText()
         self.code += '.class public %s' % self.currentClass + '\n'
@@ -96,32 +130,39 @@ def enterMethodDeclaration(self, ctx:MinijavaParser.MethodDeclarationContext):
             self.code += 'invokenonvirtual java/lang/Object/<init>()V' + '\n'
             self.code += 'return' + '\n'
             self.code += '.end method' + '\n'
-        self.currentMethodType = ctx.getChild(1).getText()
-        method_name = ctx.getChild(2).getText()
-
-        self.code += '.method public %s' % method_name
+        method_type = ctx.getChild(1).getText()
+        self.currentMethod = ctx.getChild(2).getText()
+        self.code += '.method public %s' % self.currentMethod
 
         if ctx.getChild(4).getText() == ')':
-            return_type_representation = self.get_representation(self.currentMethodType)
+            return_type_representation = self.get_representation(method_type)
             self.code += '()%s' % return_type_representation + '\n'
 
     def exitMethodDeclaration(self, ctx: MinijavaParser.MethodDeclarationContext):
         self.code += '.end method' + '\n'
 
     def enterParameterList(self, ctx:MinijavaParser.ParameterListContext):
         self.code += '('
+        self.code += self.get_method_inp_type(self.currentMethod)
 
     def exitParameterList(self, ctx: MinijavaParser.ParameterListContext):
-        return_type_representation = self.get_representation(self.currentMethodType)
+        method_type = self.get_method_type(self.currentMethod)
+        return_type_representation = self.get_representation(method_type)
         self.code += ')%s' % return_type_representation + '\n'
 
     def enterMethodBody(self, ctx:MinijavaParser.MethodBodyContext):
         self.code += '.limit stack 10000' + '\n'
+        self.code += '.limit locals 1000' + '\n'
         #todo implement .limit locals
         self.code += ''
 
     def exitMethodBody(self, ctx:MinijavaParser.MethodBodyContext):
-        self.code += self.get_return_by_type(self.currentMethodType) + '\n'
+        method_type = self.get_method_type(self.currentMethod)
+        self.code += self.get_return_by_type(method_type) + '\n'
+
+    def exitNotExpression(self, ctx:MinijavaParser.NotExpressionContext):
+        self.code += 'ldc 1' + '\n'
+        self.code += 'ixor' + '\n'
 
     def enterObjectInstantiationExpression(self, ctx:MinijavaParser.ObjectInstantiationExpressionContext):
         object_class_name = ctx.getChild(1).getText()
@@ -136,20 +177,19 @@ def exitObjectInstantiationExpression(self, ctx:MinijavaParser.ObjectInstantiati
     def exitMethodCallExpression(self, ctx: MinijavaParser.MethodCallExpressionContext):
         #todo implement method inputs
         method_name = ctx.getChild(2).getText()
-        print("gi")
-        print(self.lastExpressionType)
-        print(method_name)
         class_properties = self.symbolTable[self.lastExpressionType][method_name]
+        input_types = self.get_method_inp_type(method_name, self.lastExpressionType)
         return_type_representation = self.get_representation(class_properties["return_type"])
-        self.code += 'invokevirtual %s/%s(%s)%s' % (self.lastExpressionType, method_name, '', return_type_representation) + '\n'
+        self.code += 'invokevirtual %s/%s(%s)%s' % (self.lastExpressionType, method_name, input_types, return_type_representation) + '\n'
 
     def enterLocalDeclaration(self, ctx:MinijavaParser.LocalDeclarationContext):
         #todo
-        var_name = ctx.getChild(1).getText()
+        var_name = ctx.getChild(0).getChild(1).getText()
         var_properties= self.symbolTable[self.currentClass][var_name]
+        var_id = var_properties['id']
         if var_properties['return_type'] == 'int':
             self.code += 'bipush 0' + '\n'
-            self.code += 'istore' + '\n'
+            self.code += 'istore %s' % var_id + '\n'
 
     def enterVariableAssignmentStatement(self, ctx:MinijavaParser.VariableAssignmentStatementContext):
         name = ctx.getChild(0).getText()
@@ -158,6 +198,10 @@ def enterVariableAssignmentStatement(self, ctx:MinijavaParser.VariableAssignment
         if type == 'field':
             self.code += 'aload 0 ; push this' + '\n'
 
+    def enterIfElseStatement(self, ctx:MinijavaParser.IfElseStatementContext):
+        lable = self.get_new_lable()
+        self.code += ''
+
     #todo var type
     def exitVariableAssignmentStatement(self, ctx:MinijavaParser.VariableAssignmentStatementContext):
         name = ctx.getChild(0).getText()
@@ -187,6 +231,23 @@ def exitBasicMathExpression(self, ctx:MinijavaParser.BasicMathExpressionContext)
         elif type == '-':
             self.code += "isub" + '\n'
 
+    def exitLtExpression(self, ctx:MinijavaParser.LtExpressionContext):
+        l1 = self.get_new_lable()
+        l2 = self.get_new_lable()
+        print()
+        print("enterLtExpression")
+        self.code += 'isub' + '\n'
+        self.code += 'ifle %s' % l1 + '\n'
+        self.code += 'ldc 0' + '\n'
+        self.code += 'goto %s' % l2 + '\n'
+        self.code += '%s:' % l1 + '\n'
+        self.code += 'ldc 1' + '\n'
+        self.code += '%s:' % l2 + '\n'
+
+        self.remove_last_lable()
+        self.remove_last_lable()
+
+
     def enterIntLitExpression(self, ctx:MinijavaParser.IntLitExpressionContext):
         literal = ctx.getChild(0).getText()
         print("enterIntLitExpression %s" % literal)
@@ -201,6 +262,11 @@ def enterIdentifierExpression(self, ctx:MinijavaParser.IdentifierExpressionConte
             representation = self.get_representation(return_type)
             self.code += 'aload 0 ; push this' + '\n'
             self.code += 'getfield %s/%s %s' % (self.currentClass, name, representation) + '\n'
+        elif type == 'var':
+            var_id = properties['id'] - 1
+            return_type = properties['return_type']
+            upcode = self.get_representation(return_type).lower() + 'load'
+            self.code += '%s %d' % (upcode, var_id) + '\n'
 
     def enterPrintStatement(self, ctx: MinijavaParser.PrintStatementContext):
         self.code += "getstatic java/lang/System/out Ljava/io/PrintStream;" + '\n'
@@ -209,10 +275,6 @@ def exitPrintStatement(self, ctx:MinijavaParser.PrintStatementContext):
         self.code += "invokevirtual java/io/PrintStream/println(I)V" + '\n'
 
 
-    def enterLtExpression(self, ctx:MinijavaParser.LtExpressionContext):
-        print()
-        print("enterLtExpression")
-        self.code += ""
 
     def enterAndExpression(self, ctx:MinijavaParser.AndExpressionContext):
         print()

MinijavaSymbolVisitor.py

@@ -5,6 +5,7 @@ class MinijavaSymbolVisitor(MinijavaVisitor):
     def __init__(self):
         super().__init__()
         self.currentClass = ""
+        self.currentMethod = ""
         self.symbolTable = {}
         self.variables = {}
 
@@ -40,10 +41,24 @@ def visitVarDeclaration(self, ctx: MinijavaParser.VarDeclarationContext):
     def visitMethodDeclaration(self, ctx:MinijavaParser.MethodDeclarationContext):
         method_type = ctx.getChild(1).getText()
         method_name = ctx.getChild(2).getText()
-        self.symbolTable[self.currentClass][method_name] = {type: "method", "return_type": method_type, "inputes": []}
+        self.currentMethod = method_name
+        self.symbolTable[self.currentClass][method_name] = {"type": "method", "return_type": method_type, "inputs": []}
 
         return self.visitChildren(ctx)
 
+    def visitParameterList(self, ctx:MinijavaParser.ParameterListContext):
+        for child in ctx.getChildren():
+            if child.getText() != ',':
+                param_type = child.getChild(0).getText()
+                param_name = child.getChild(1).getText()
+                param_prop = (param_type, param_name)
+                print(param_prop, "ZZZZZZ")
+                self.symbolTable[self.currentClass][self.currentMethod]["inputs"].append(param_prop)
+                var_type = param_type
+                var_name = param_name
+                var_id = self.new_variable(var_name)
+                self.symbolTable[self.currentClass][var_name] = {"type": "var", "return_type": var_type, "id": var_id}
+
     # todo implement input param
     def visitParameter(self, ctx: MinijavaParser.ParameterContext):
         return self.visitChildren(ctx)

sample/class4.minijava

@@ -0,0 +1,15 @@
+class class4{
+    public static void main(String[] a) {
+	System.out.println(new Dynamic().twice(7));
+    }
+}
+
+class Dynamic{
+
+    int fixula;
+
+    public int twice(int b){
+        fixula = 'string';
+	    return fixula * b;
+    }
+}

sample/factorial.minijava

@@ -0,0 +1,17 @@
+class factorial{
+    public static void main(String[] a) {
+	System.out.println(new Fac().ComputeFac(10));
+    }
+}
+
+class Fac{
+
+    public int ComputeFac(int num){
+	int num_aux;
+	if (!num<1)
+	    num_aux = 1;
+	else
+	    num_aux = num*(this.ComputeFac(num-1));
+	return num_aux;
+    }
+}

sample/math.minijava

@@ -0,0 +1,5 @@
+class Math{
+    public static void main(String[] a){
+	System.out.println(3+4*5*6+7-2*7);
+    }
+}