From 4f2599d05382598590d18e4a84df3f30aee6c8c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Krau=C3=9F=2C=20Josefine?= Date: Thu, 9 May 2024 17:28:29 +0200 Subject: [PATCH] interface changes and some typecheck for code block. also some minor changes in blockstatement structure --- .idea/compiler.xml | 4 +--- NichtHaskell.iml | 2 +- src/main/java/Compiler.java | 21 ++++++++++++++++++- .../abstractSyntaxTree/Class/MethodDecl.java | 13 +++++++----- src/main/java/abstractSyntaxTree/Program.java | 14 +++++++++---- .../Statement/BlockStatement.java | 21 ++++++++++++------- .../Statement/EmptyStatement.java | 8 +++++++ .../Statement/IStatement.java | 5 +++++ .../Statement/IfElseStatement.java | 8 +++++++ .../Statement/IfStatement.java | 8 +++++++ .../Statement/ReturnStatement.java | 8 +++++++ .../Statement/WhileStatement.java | 8 +++++++ .../AssignStatementExpression.java | 7 +++++++ .../MethodCallStatementExpression.java | 6 ++++++ .../NewStatementExpression.java | 8 +++++++ 15 files changed, 119 insertions(+), 22 deletions(-) diff --git a/.idea/compiler.xml b/.idea/compiler.xml index 1181d5e..8643296 100644 --- a/.idea/compiler.xml +++ b/.idea/compiler.xml @@ -6,10 +6,8 @@ + - - - \ No newline at end of file diff --git a/NichtHaskell.iml b/NichtHaskell.iml index b18ce81..2e9d176 100644 --- a/NichtHaskell.iml +++ b/NichtHaskell.iml @@ -1,5 +1,5 @@ - + diff --git a/src/main/java/Compiler.java b/src/main/java/Compiler.java index 871cc22..8f66cec 100644 --- a/src/main/java/Compiler.java +++ b/src/main/java/Compiler.java @@ -2,6 +2,7 @@ import abstractSyntaxTree.Class.FieldDecl; import abstractSyntaxTree.Class.MethodDecl; import abstractSyntaxTree.Class.RefType; import abstractSyntaxTree.Program; +import abstractSyntaxTree.Statement.BlockStatement; import gen.DecafLexer; import gen.DecafParser; import org.antlr.v4.runtime.CharStream; @@ -51,8 +52,26 @@ public class Compiler { System.out.println(tree); - Program abstractSyntaxTree = new Program(new ArrayList<>()); + List fieldDecls = new ArrayList<>(); + + FieldDecl fieldDecl = new FieldDecl("int", "i"); + fieldDecls.add(fieldDecl); + +// FieldDecl fieldDecl2 = new FieldDecl("char", "i"); +// fieldDecls.add(fieldDecl2); + + List methodDecls = new ArrayList<>(); + + MethodDecl methodDecl = new MethodDecl("ClassA", "int", "m", new ArrayList<>(), new BlockStatement(new ArrayList<>(), "void")); + methodDecls.add(methodDecl); + +// MethodDecl methodDecl2 = new MethodDecl("ClassA", "int", "m", new ArrayList<>(), new ArrayList<>()); +// methodDecls.add(methodDecl2); + + abstractSyntaxTree.classes.add(new RefType("MyClass", fieldDecls, methodDecls, false)); + + abstractSyntaxTree.typeCheck(); diff --git a/src/main/java/abstractSyntaxTree/Class/MethodDecl.java b/src/main/java/abstractSyntaxTree/Class/MethodDecl.java index ef7181f..534bbe4 100644 --- a/src/main/java/abstractSyntaxTree/Class/MethodDecl.java +++ b/src/main/java/abstractSyntaxTree/Class/MethodDecl.java @@ -2,11 +2,13 @@ package abstractSyntaxTree.Class; import TypeCheck.TypeCheckResult; import abstractSyntaxTree.Program; +import abstractSyntaxTree.Statement.BlockStatement; import abstractSyntaxTree.Statement.IStatement; import org.objectweb.asm.ClassWriter; import java.util.HashMap; import java.util.List; +import java.util.Map; public class MethodDecl implements IClass { @@ -14,11 +16,11 @@ public class MethodDecl implements IClass { public String name; public List parameters; public String returnType; - public List codeBlock; + public BlockStatement codeBlock; - // save localvars + public Map localVars; - public MethodDecl(String classThatContainsMethod, String returnType, String name, List parameters, List codeBlock){ + public MethodDecl(String classThatContainsMethod, String returnType, String name, List parameters, BlockStatement codeBlock){ this.classThatContainsMethod = classThatContainsMethod; this.returnType = returnType; this.name = name; @@ -27,8 +29,9 @@ public class MethodDecl implements IClass { } public TypeCheckResult typeCheck(HashMap>>> methodContext, HashMap> typeContext) throws Exception { - // write localvars - // jede methode als block statement aufrufen + // jede methode als block statement aufrufen und jede neue locale varibale in localvars schreiben + + codeBlock.typeCheck(methodContext, typeContext); return null; } diff --git a/src/main/java/abstractSyntaxTree/Program.java b/src/main/java/abstractSyntaxTree/Program.java index 792d689..d6fa9a5 100644 --- a/src/main/java/abstractSyntaxTree/Program.java +++ b/src/main/java/abstractSyntaxTree/Program.java @@ -27,29 +27,35 @@ public class Program { public TypeCheckResult typeCheck() throws Exception{ + this.typeContext = new HashMap<>(); + this.methodContext = new HashMap<>(); + for(RefType oneClass : classes){ // build type context - this.typeContext = new HashMap<>(); - HashMap classVars = new HashMap<>(); for (FieldDecl fieldDecl: oneClass.fieldDecls){ classVars.put(fieldDecl.type, fieldDecl.identifier); } typeContext.put(oneClass.name, classVars); + // build method context HashMap> methodIdentifierAndParameter = new HashMap<>(); HashMap>> returnTypeAndMethod = new HashMap<>(); for (MethodDecl methodDecl : oneClass.methodDecls){ methodIdentifierAndParameter.put(methodDecl.name, methodDecl.parameters); returnTypeAndMethod.put(methodDecl.returnType, methodIdentifierAndParameter); } - this.methodContext = new HashMap<>(); methodContext.put(oneClass.name, returnTypeAndMethod); + } + // typecheck each class + TypeCheckResult result = new TypeCheckResult(); + for(RefType oneClass : classes){ oneClass.typeCheck(methodContext, typeContext); } - return null; + result.type = "program"; + return result; } public void codeGen() throws Exception{ diff --git a/src/main/java/abstractSyntaxTree/Statement/BlockStatement.java b/src/main/java/abstractSyntaxTree/Statement/BlockStatement.java index da8e26d..cac259d 100644 --- a/src/main/java/abstractSyntaxTree/Statement/BlockStatement.java +++ b/src/main/java/abstractSyntaxTree/Statement/BlockStatement.java @@ -11,32 +11,37 @@ public class BlockStatement extends AbstractType implements IStatement{ //We will need a parameter which holds the symbol table HashMap localVars; - HashMap typeIndentifierTable; // from program + String returnType; List statements; // do we need expression, statementexpression - public BlockStatement(List statements, HashMap localVars, HashMap typeIndentifierTable){ - + public BlockStatement(List statements, String returnType){ this.statements = statements; + this.returnType = returnType; } + @Override public TypeCheckResult typeCheck() throws Exception { + return null; + } + + @Override + public TypeCheckResult typeCheck(HashMap>>> methodContext, HashMap> typeContext) throws Exception { TypeCheckResult result = new TypeCheckResult(); if(statements.size() == 0){ result.type = "void"; } - TypeCheckResult blockType = null; + TypeCheckResult blockType = new TypeCheckResult(); for (IStatement statement : statements) { TypeCheckResult typeOfCurrentStatement = statement.typeCheck(); - if (blockType == null) { - blockType = typeOfCurrentStatement; - } else if (!typeOfCurrentStatement.equals(blockType) && !blockType.equals("void")) { - throw new IllegalArgumentException("different statement types"); + if (!typeOfCurrentStatement.equals(this.returnType) && !blockType.equals("void")) { + throw new IllegalArgumentException("Block returns type that it should not return"); } } + // todo check if the block returns the needed return type in every case return result; } diff --git a/src/main/java/abstractSyntaxTree/Statement/EmptyStatement.java b/src/main/java/abstractSyntaxTree/Statement/EmptyStatement.java index 01818d7..5065e7a 100644 --- a/src/main/java/abstractSyntaxTree/Statement/EmptyStatement.java +++ b/src/main/java/abstractSyntaxTree/Statement/EmptyStatement.java @@ -4,6 +4,9 @@ import TypeCheck.TypeCheckResult; import TypeCheck.AbstractType; import org.objectweb.asm.MethodVisitor; +import java.util.HashMap; +import java.util.List; + public class EmptyStatement extends AbstractType implements IStatement{ @Override public TypeCheckResult typeCheck() throws Exception { @@ -12,6 +15,11 @@ public class EmptyStatement extends AbstractType implements IStatement{ return result; } + @Override + public TypeCheckResult typeCheck(HashMap>>> methodContext, HashMap> typeContext) throws Exception { + return null; + } + @Override public void codeGen(MethodVisitor mv) throws Exception { //An empty statement does not generate any code diff --git a/src/main/java/abstractSyntaxTree/Statement/IStatement.java b/src/main/java/abstractSyntaxTree/Statement/IStatement.java index d15e56b..bcc5162 100644 --- a/src/main/java/abstractSyntaxTree/Statement/IStatement.java +++ b/src/main/java/abstractSyntaxTree/Statement/IStatement.java @@ -3,11 +3,16 @@ package abstractSyntaxTree.Statement; import TypeCheck.TypeCheckResult; import org.objectweb.asm.MethodVisitor; +import java.util.HashMap; +import java.util.List; + public interface IStatement { TypeCheckResult typeCheck() throws Exception; + TypeCheckResult typeCheck(HashMap>>> methodContext, HashMap> typeContext) throws Exception; + void codeGen(MethodVisitor mv) throws Exception; } diff --git a/src/main/java/abstractSyntaxTree/Statement/IfElseStatement.java b/src/main/java/abstractSyntaxTree/Statement/IfElseStatement.java index d8ac01e..1afc7bb 100644 --- a/src/main/java/abstractSyntaxTree/Statement/IfElseStatement.java +++ b/src/main/java/abstractSyntaxTree/Statement/IfElseStatement.java @@ -5,6 +5,9 @@ import TypeCheck.AbstractType; import abstractSyntaxTree.Expression.IExpression; import org.objectweb.asm.*; +import java.util.HashMap; +import java.util.List; + public class IfElseStatement extends AbstractType implements IStatement{ IExpression condition; IStatement ifStatement; @@ -37,6 +40,11 @@ public class IfElseStatement extends AbstractType implements IStatement{ return result; } + @Override + public TypeCheckResult typeCheck(HashMap>>> methodContext, HashMap> typeContext) throws Exception { + return null; + } + @Override public void codeGen(MethodVisitor mv) throws Exception { diff --git a/src/main/java/abstractSyntaxTree/Statement/IfStatement.java b/src/main/java/abstractSyntaxTree/Statement/IfStatement.java index 1c8461c..29ca025 100644 --- a/src/main/java/abstractSyntaxTree/Statement/IfStatement.java +++ b/src/main/java/abstractSyntaxTree/Statement/IfStatement.java @@ -5,6 +5,9 @@ import TypeCheck.AbstractType; import abstractSyntaxTree.Expression.IExpression; import org.objectweb.asm.*; +import java.util.HashMap; +import java.util.List; + public class IfStatement extends AbstractType implements IStatement{ IExpression condition; @@ -30,6 +33,11 @@ public class IfStatement extends AbstractType implements IStatement{ return result; } + @Override + public TypeCheckResult typeCheck(HashMap>>> methodContext, HashMap> typeContext) throws Exception { + return null; + } + @Override public void codeGen(MethodVisitor mv) throws Exception { diff --git a/src/main/java/abstractSyntaxTree/Statement/ReturnStatement.java b/src/main/java/abstractSyntaxTree/Statement/ReturnStatement.java index 976de6e..f409ea2 100644 --- a/src/main/java/abstractSyntaxTree/Statement/ReturnStatement.java +++ b/src/main/java/abstractSyntaxTree/Statement/ReturnStatement.java @@ -5,6 +5,9 @@ import TypeCheck.AbstractType; import abstractSyntaxTree.Expression.IExpression; import org.objectweb.asm.*; +import java.util.HashMap; +import java.util.List; + public class ReturnStatement extends AbstractType implements IStatement{ IExpression expression; @@ -26,6 +29,11 @@ public class ReturnStatement extends AbstractType implements IStatement{ return result; } + @Override + public TypeCheckResult typeCheck(HashMap>>> methodContext, HashMap> typeContext) throws Exception { + return null; + } + //TODO: We do not differentiate between primitive types and reference types // This is a problem at "BinaryExpression" and here because we need to know the type to return diff --git a/src/main/java/abstractSyntaxTree/Statement/WhileStatement.java b/src/main/java/abstractSyntaxTree/Statement/WhileStatement.java index e923fa1..d325e0a 100644 --- a/src/main/java/abstractSyntaxTree/Statement/WhileStatement.java +++ b/src/main/java/abstractSyntaxTree/Statement/WhileStatement.java @@ -5,6 +5,9 @@ import TypeCheck.AbstractType; import abstractSyntaxTree.Expression.IExpression; import org.objectweb.asm.*; +import java.util.HashMap; +import java.util.List; + public class WhileStatement extends AbstractType implements IStatement { IExpression condition; IStatement statement; @@ -30,6 +33,11 @@ public class WhileStatement extends AbstractType implements IStatement { return result; } + @Override + public TypeCheckResult typeCheck(HashMap>>> methodContext, HashMap> typeContext) throws Exception { + return null; + } + @Override public void codeGen(MethodVisitor mv) throws Exception { Label conditionFalse = new Label(); diff --git a/src/main/java/abstractSyntaxTree/StatementExpression/AssignStatementExpression.java b/src/main/java/abstractSyntaxTree/StatementExpression/AssignStatementExpression.java index 4085494..281dcc8 100644 --- a/src/main/java/abstractSyntaxTree/StatementExpression/AssignStatementExpression.java +++ b/src/main/java/abstractSyntaxTree/StatementExpression/AssignStatementExpression.java @@ -9,6 +9,8 @@ import abstractSyntaxTree.Expression.VarRefExpression; import abstractSyntaxTree.Statement.IStatement; import org.objectweb.asm.*; +import java.util.HashMap; +import java.util.List; import java.util.Objects; public class AssignStatementExpression extends AbstractType implements IExpression, IStatement { @@ -32,6 +34,11 @@ public class AssignStatementExpression extends AbstractType implements IExpressi return result; } + @Override + public TypeCheckResult typeCheck(HashMap>>> methodContext, HashMap> typeContext) throws Exception { + return null; + } + @Override public void codeGen(MethodVisitor mv) throws Exception { left.codeGen(mv); diff --git a/src/main/java/abstractSyntaxTree/StatementExpression/MethodCallStatementExpression.java b/src/main/java/abstractSyntaxTree/StatementExpression/MethodCallStatementExpression.java index 2907a43..1129f47 100644 --- a/src/main/java/abstractSyntaxTree/StatementExpression/MethodCallStatementExpression.java +++ b/src/main/java/abstractSyntaxTree/StatementExpression/MethodCallStatementExpression.java @@ -10,6 +10,7 @@ import org.objectweb.asm.ClassWriter; import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes; +import java.util.HashMap; import java.util.List; public class MethodCallStatementExpression extends AbstractType implements IExpression, IStatement { @@ -43,6 +44,11 @@ public class MethodCallStatementExpression extends AbstractType implements IExpr return result; } + @Override + public TypeCheckResult typeCheck(HashMap>>> methodContext, HashMap> typeContext) throws Exception { + return null; + } + //Errors occur due to the change in parameter in the RefType class @Override public void codeGen(MethodVisitor mv) throws Exception { diff --git a/src/main/java/abstractSyntaxTree/StatementExpression/NewStatementExpression.java b/src/main/java/abstractSyntaxTree/StatementExpression/NewStatementExpression.java index f54986c..7350a9b 100644 --- a/src/main/java/abstractSyntaxTree/StatementExpression/NewStatementExpression.java +++ b/src/main/java/abstractSyntaxTree/StatementExpression/NewStatementExpression.java @@ -6,12 +6,20 @@ import abstractSyntaxTree.Expression.IExpression; import abstractSyntaxTree.Statement.IStatement; import org.objectweb.asm.MethodVisitor; +import java.util.HashMap; +import java.util.List; + public class NewStatementExpression extends AbstractType implements IExpression, IStatement { @Override public TypeCheckResult typeCheck() throws Exception { return null; } + @Override + public TypeCheckResult typeCheck(HashMap>>> methodContext, HashMap> typeContext) throws Exception { + return null; + } + @Override public void codeGen(MethodVisitor mv) throws Exception { throw new Exception("CodeGen not implemented for NewStatementExpression");