i22006/Compilerbau2024AbsolutNichtHaskell
i22006/Compilerbau2024AbsolutNichtHaskell
2
0
Fork 0
mirror of https://github.com/JonathanFleischmann/CompilerULTIMATE.git synced 2024-12-28 17:28:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' of https://github.com/JonathanFleischmann/CompilerULTIMATE

Browse Source
This commit is contained in:
laurenz 2024-05-07 20:30:11 +02:00
commit a2fc1686b1
25 changed files with 828 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/main/java/de/maishai/typedast/typedclass/TypedClass.java
View File

@ -13,9 +13,12 @@ import java.util.Map;
@Data @Data
public class TypedClass implements Node { public class TypedClass implements Node {
private Boolean isPublic;
private TypedId typedId; private TypedId typedId;
private List<TypedField> typedFields; private List<TypedField> typedFields;
private List<TypedMethod> typedMethods; private List<TypedMethod> typedMethods;
private TypedMainMethod typedMainMethod;
private List<TypedConstructor> typedConstructors;
@Override @Override
public Type typeCheck(Map<String, Type> localVar, Map<String, TypedClass> classes) { public Type typeCheck(Map<String, Type> localVar, Map<String, TypedClass> classes) {

1
src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java
View File

@ -12,6 +12,7 @@ import java.util.Map;
@Data @Data
public class TypedConstructor implements Node { public class TypedConstructor implements Node {
private Boolean isPublic;
private TypedId typedId; private TypedId typedId;
private List<TypedParameter> typedParameters; private List<TypedParameter> typedParameters;
private TypedBlock typedBlock; private TypedBlock typedBlock;

2
src/main/java/de/maishai/typedast/typedclass/TypedFieldId.java
View File

@ -8,7 +8,7 @@ import lombok.Data;
import java.util.Map; import java.util.Map;
@Data @Data
public class TypedFieldId implements Node { public class TypedFieldId implements Expression {
private Boolean field; private Boolean field;
private Expression recipient; private Expression recipient;
private TypedId typedId; private TypedId typedId;

1
src/main/java/de/maishai/typedast/typedclass/TypedMethod.java
View File

@ -13,6 +13,7 @@ import java.util.Map;
@Data @Data
public class TypedMethod implements Node { public class TypedMethod implements Node {
private Boolean isPublic;
private TypedId typedId; private TypedId typedId;
private Type returnType; private Type returnType;
private List<TypedParameter> typedParameters; private List<TypedParameter> typedParameters;

135
src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithConstructor.java Normal file
View File

@ -0,0 +1,135 @@
//public class ClassWithConstructor {
// int x;
// public classWithConstructor() {
// this.x = 10;
// int i;
// for (i = 0; i < 6; i = i + 1) {
// int j;
// for (j = 0; j < this.x; j += 1) {
// this.x = this.x * this.x;
// }
// }
// }
//}
import de.maishai.ast.*;
import de.maishai.ast.records.*;
import de.maishai.ast.records.Class;
import java.util.List;
public class AbstractSyntax_ClassWithConstructor {
public static Class get() {
List<Field> fields = List.of(
new Field(
new Id("x"),
Type.INT
)
);
List<Method> methods = List.of();
List<Constructor> constructors = getConstructors();
return new Class(
true,
new Id("ClassWithConstructor"),
fields,
methods,
null,
constructors
);
}
private static List<Constructor> getConstructors() {
return List.of(getConstructor1());
}
private static Constructor getConstructor1() {
List<Parameter> parameters = List.of();
List<LocalVariable> localVariables = List.of(
new LocalVariable(
new Id("i"),
Type.INT
)
);
List<Statement> statementList = List.of(
new Assignment(
new Id("x"),
AssignSign.ASSIGN,
new IntLiteral(10)
),
new For(
new Assignment(
new Id("i"),
AssignSign.ASSIGN,
new IntLiteral(0)
),
new Binary(
new Id("i"),
Operator.LT,
new IntLiteral(6)
),
new Assignment(
new Id("i"),
AssignSign.ASSIGN,
new Binary(
new Id("i"),
Operator.ADD,
new IntLiteral(1)
)
),
new Block(
List.of(
new LocalVariable(
new Id("j"),
Type.INT
)
),
List.of(
new For(
new Assignment(
new Id("j"),
AssignSign.ASSIGN,
new IntLiteral(0)
),
new Binary(
new Id("j"),
Operator.LT,
new Id("x")
),
new Assignment(
new Id("j"),
AssignSign.ADD_ASSIGN,
new IntLiteral(1)
),
new Block(
List.of(),
List.of(
new Assignment(
new Id("x"),
AssignSign.ASSIGN,
new Binary(
new Id("x"),
Operator.MUL,
new Id("x")
)
)
)
)
)
)
)
)
);
Block block = new Block(
localVariables,
statementList
);
return new Constructor(
true,
new Id("ClassWithConstructor"),
parameters,
block
);
}
}

135
src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithConstructorAndMethodCall.java Normal file
View File

@ -0,0 +1,135 @@
//public class ClassWithConstructorAndMethodCall {
// int x;
//
// public ClassWithConstructorAndMethodCall() {
// this.x = 10;
// while (methodCall()) {
// this.x = this.x * this.x;
// }
// }
//
// public boolean methodCall() {
// if (this.x > 100) {
// return false;
// } else {
// return true;
// }
// }
//}
import de.maishai.ast.AssignSign;
import de.maishai.ast.Operator;
import de.maishai.ast.ReturnType;
import de.maishai.ast.Type;
import de.maishai.ast.records.*;
import de.maishai.ast.records.Class;
import java.util.List;
public class AbstractSyntax_ClassWithConstructorAndMethodCall {
public static Class get() {
List<Field> fieldList = List.of(
new Field(
new Id("x"),
Type.INT
)
);
List<Method> methodList = getMethods();
List<Constructor> constructorList = getConstructors();
return new Class(
true,
new Id("ClassWithConstructorAndMethodCall"),
fieldList,
methodList,
null,
constructorList
);
}
private static List<Constructor> getConstructors() {
return List.of(getConstructor1());
}
private static Constructor getConstructor1() {
Block block = new Block(
List.of(),
List.of(
new Assignment(
new Id("x"),
AssignSign.ASSIGN,
new IntLiteral(10)
),
new While(
new MethodCall(
false,
null,
new Id("methodCall"),
List.of()
),
new Block(
List.of(),
List.of(
new Assignment(
new Id("x"),
AssignSign.ASSIGN,
new Binary(
new Id("x"),
Operator.MUL,
new Id("x")
)
)
)
)
)
)
);
return new Constructor(
true,
new Id("ClassWithConstructorAndMethodCall"),
List.of(),
block
);
}
private static List<Method> getMethods() {
return List.of(getMethod1());
}
private static Method getMethod1() {
return new Method(
true,
ReturnType.BOOL,
new Id("methodCall"),
List.of(),
new Block(
List.of(),
List.of(
new IfElse(
new Binary(
new Id("x"),
Operator.GT,
new IntLiteral(100)
),
new Block(
List.of(),
List.of(
new Return(
new BoolLiteral(false)
)
)
),
new Block(
List.of(),
List.of(
new Return(
new BoolLiteral(true)
)
)
)
)
)
)
);
}
}

130
src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithConstructorWithParameters.java Normal file
View File

@ -0,0 +1,130 @@
//public class ClassWithConstructorWithParameters {
// int x;
// public classWithConstructorWithParameters(int startValue, int repetitions) {
// this.x = startValue;
// while (repetitions > 0) {
// int innerRepetitions;
// innerRepetitions = this.x;
// while (innerRepetitions > 0) {
// this.x = this.x * this.x;
// innerRepetitions -= 1;
// }
// repetitions -= 1;
// }
// }
//}
import de.maishai.ast.AssignSign;
import de.maishai.ast.Operator;
import de.maishai.ast.records.*;
import de.maishai.ast.Type;
import de.maishai.ast.records.Class;
import java.util.List;
public class AbstractSyntax_ClassWithConstructorWithParameters {
public static Class get() {
List<Field> fields = List.of(
new Field(
new Id("x"),
Type.INT
)
);
List<Constructor> constructors = getConstructors();
return new Class(
true,
new Id("ClassWithConstructorWithParameters"),
fields,
List.of(),
null,
constructors
);
}
private static List<Constructor> getConstructors() {
return List.of(getConstructor1());
}
private static Constructor getConstructor1() {
List<Parameter> parameters = List.of(
new Parameter(
"startValue",
Type.INT
),
new Parameter(
"repetitions",
Type.INT
)
);
Block block = new Block(
List.of(),
List.of(
new Assignment(
new Id("x"),
AssignSign.ASSIGN,
new Id("startValue")
),
new While(
new Binary(
new Id("repetitions"),
Operator.GT,
new IntLiteral(0)
),
new Block(
List.of(
new LocalVariable(
new Id("innerRepetitions"),
Type.INT
)
),
List.of(
new Assignment(
new Id("innerRepetitions"),
AssignSign.ASSIGN,
new Id("x")
),
new While(
new Binary(
new Id("repetitions"),
Operator.GT,
new IntLiteral(0)
),
new Block(
List.of(),
List.of(
new Assignment(
new Id("x"),
AssignSign.ASSIGN,
new Binary(
new Id("x"),
Operator.MUL,
new Id("x")
)
),
new Assignment(
new Id("innerRepetitions"),
AssignSign.SUB_ASSIGN,
new IntLiteral(1)
)
)
)
),
new Assignment(
new Id("repetitions"),
AssignSign.SUB_ASSIGN,
new IntLiteral(1)
)
)
)
)
)
);
return new Constructor(
true,
new Id("classWithConstructorWithParameters"),
parameters,
block
);
}
}

33
src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithField.java Normal file
View File

@ -0,0 +1,33 @@
//public class ClassWithField {
// int x;
//}
import de.maishai.ast.records.Class;
import de.maishai.ast.Type;
import de.maishai.ast.records.Constructor;
import de.maishai.ast.records.Field;
import de.maishai.ast.records.Id;
import de.maishai.ast.records.Method;
import java.util.List;
public class AbstractSyntax_ClassWithField {
public static Class get() {
List<Field> fields = List.of(
new Field(
new Id("x"),
Type.INT
)
);
List<Method> methods = List.of();
List<Constructor> constructors = List.of();
return new Class(
true,
new Id("ClassWithAssignment"),
fields,
methods,
null,
constructors
);
}
}

46
src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithMethod.java Normal file
View File

@ -0,0 +1,46 @@
//public class ClassWithMethod {
// public boolean method() {
// return false;
// }
//}
import de.maishai.ast.ReturnType;
import de.maishai.ast.records.Class;
import de.maishai.ast.records.*;
import java.util.List;
public class AbstractSyntax_ClassWithMethod {
public static Class get() {
List<Method> methods = getMethods();
return new Class(
true,
new Id("ClassWithMethod"),
List.of(),
methods,
null,
List.of()
);
}
private static List<Method> getMethods() {
return List.of(getMethod1());
}
private static Method getMethod1() {
return new Method(
true,
ReturnType.BOOL,
new Id("method"),
List.of(),
new Block(
List.of(),
List.of(
new Return(
new BoolLiteral(false)
)
)
)
);
}
}

86
src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithMethodAndField.java Normal file
View File

@ -0,0 +1,86 @@
//public class ClassWithMethodAndField {
// char c;
//
// public ClassWithMethodAndField(char character) {
// this.c = character;
// }
//
// public boolean method() {
// return true;
// }
//}
import de.maishai.ast.*;
import de.maishai.ast.records.*;
import de.maishai.ast.records.Class;
import java.util.List;
class AbstractSyntax_ClassWithMethodAndField {
public static Class get() {
List<Field> fields = List.of(
new Field(
new Id("c"),
Type.CHAR
)
);
List<Method> methods = getMethods();
List<Constructor> constructors = getConstructors();
return new Class(
false,
new Id("ClassWithMethodAndField"),
fields,
methods,
null,
constructors
);
}
private static List<Constructor> getConstructors() {
return List.of(getConstructor1());
}
private static Constructor getConstructor1() {
return new Constructor(
true,
new Id("ClassWithMethodAndField"),
List.of(
new Parameter(
"character",
Type.CHAR
)
),
new Block(
List.of(),
List.of(
new Assignment(
new Id("c"),
AssignSign.ASSIGN,
new Id("character")
)
)
)
);
}
private static List<Method> getMethods() {
return List.of(getMethod1());
}
private static Method getMethod1() {
return new Method(
true,
ReturnType.BOOL,
new Id("method"),
List.of(),
new Block(
List.of(),
List.of(
new Return(
new BoolLiteral(true)
)
)
)
);
}
}

137
src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithMoreComplexMethodAndMain.java Normal file
View File

@ -0,0 +1,137 @@
//public class ClassWithMoreComplexMethodAndMain {
// ClassWithMoreComplexMethodAndMain instance;
//
// public boolean moreComplexMethod() {
// int i;
// i = 11;
// boolean returnValue;
// returnValue = false;
// while (i > 0) {
// i -= 1;
// returnValue = !returnValue;
// }
// return returnValue;
// }
//
// public static void main(String[] args) {
// instance = new ClassWithMoreComplexMethodAndMain()
// }
//}
import de.maishai.ast.*;
import de.maishai.ast.records.*;
import de.maishai.ast.records.Class;
import java.util.List;
public class AbstractSyntax_ClassWithMoreComplexMethodAndMain {
public static Class get() {
Type TypeClassWithMoreComplexMethodAndMain = Type.OBJECT;
TypeClassWithMoreComplexMethodAndMain.setObjectType(new Id("ClassWithMoreComplexMethodAndMain"));
List<Field> fields = List.of(
new Field(
new Id("instance"),
TypeClassWithMoreComplexMethodAndMain
)
);
List<Method> methods = getMethods();
List<Constructor> constructors = List.of();
return new Class(
true,
new Id("ClassWithMoreComplexMethodAndMain"),
fields,
methods,
getMainMethod(),
constructors
);
}
private static List<Method> getMethods() {
return List.of(getMethod1());
}
private static Method getMethod1() {
Block block = new Block(
List.of(
new LocalVariable(
new Id("i"),
Type.INT
),
new LocalVariable(
new Id("returnValue"),
Type.BOOL
)
),
List.of(
new Assignment(
new Id("i"),
AssignSign.ASSIGN,
new IntLiteral(11)
),
new Assignment(
new Id("returnValue"),
AssignSign.ASSIGN,
new BoolLiteral(false)
),
new While(
new Binary(
new Id("i"),
Operator.GT,
new IntLiteral(0)
),
new Block(
List.of(),
List.of(
new Assignment(
new Id("i"),
AssignSign.SUB_ASSIGN,
new IntLiteral(1)
),
new Assignment(
new Id("returnValue"),
AssignSign.ASSIGN,
new Unary(
UnaryOperator.NOT,
new Id("returnValue")
)
)
)
)
),
new Return(
new Id("returnValue")
)
)
);
return new Method(
true,
ReturnType.BOOL,
new Id("moreComplexMethod"),
List.of(),
block
);
}
private static MainMethod getMainMethod() {
Type TypeClassWithMoreComplexMethodAndMain = Type.OBJECT;
TypeClassWithMoreComplexMethodAndMain.setObjectType(new Id("ClassWithMoreComplexMethodAndMain"));
List<Statement> statementList = List.of(
new Assignment(
new Id("instance"),
AssignSign.ASSIGN,
new New(
TypeClassWithMoreComplexMethodAndMain,
List.of()
)
)
);
Block block = new Block(
List.of(),
statementList
);
return new MainMethod(
block
);
}
}

20
src/main/resources/AbstractSyntax/AbstractSyntax_OnlyClass.java Normal file
View File

@ -0,0 +1,20 @@
//class OnlyClass {
//}
import de.maishai.ast.records.*;
import de.maishai.ast.records.Class;
import java.util.List;
public class AbstractSyntax_OnlyClass {
public static Class get() {
return new Class(
false,
new Id("OnlyClass"),
List.of(),
List.of(),
null,
List.of()
);
}
}

20
src/main/resources/AbstractSyntax/AbstractSyntax_PublicClass.java Normal file
View File

@ -0,0 +1,20 @@
//public class PublicClass {
//}
import de.maishai.ast.records.Class;
import de.maishai.ast.records.Id;
import java.util.List;
public class AbstractSyntax_PublicClass {
public static Class get() {
return new Class(
true,
new Id("PublicClass"),
List.of(),
List.of(),
null,
List.of()
);
}
}

3
src/main/resources/ClassWithAssignment.java
View File

@ -1,3 +0,0 @@
public class ClassWithAssignment {
int x = 10;
}

6
src/main/resources/ClassWithMethodAndAssignement.java
View File

@ -1,6 +0,0 @@
public class ClassWithMethodAndAssignement {
char c = 'c';
public boolean method() {
}
}

6
src/main/resources/ClassWithMoreComplexMethod.java
View File

@ -1,6 +0,0 @@
public class ClassWithMoreComplexMethod {
public boolean moreComplexMethod() {
int i = 0;
return true;
}
}

13
src/main/resources/JavaTestfiles/ClassWithConstructor.java Normal file
View File

@ -0,0 +1,13 @@
public class ClassWithConstructor {
int x;
public classWithConstructor() {
this.x = 10;
int i;
for (i = 0; i < 6; i = i + 1) {
int j;
for (j = 0; j < this.x; j += 1) {
this.x = this.x * this.x;
}
}
}
}

18
src/main/resources/JavaTestfiles/ClassWithConstructorAndMethodCall.java Normal file
View File

@ -0,0 +1,18 @@
public class ClassWithConstructorAndMethodCall {
int x;
public ClassWithConstructorAndMethodCall() {
this.x = 10;
while (methodCall()) {
this.x = this.x * this.x;
}
}
public boolean methodCall() {
if (this.x > 100) {
return false;
} else {
return true;
}
}
}

15
src/main/resources/JavaTestfiles/ClassWithConstructorWithParameters.java Normal file
View File

@ -0,0 +1,15 @@
public class ClassWithConstructorWithParameters {
int x;
public classWithConstructorWithParameters(int startValue, int repetitions) {
this.x = startValue;
while (repetitions > 0) {
int innerRepetitions;
innerRepetitions = this.x;
while (innerRepetitions > 0) {
this.x = this.x * this.x;
innerRepetitions -= 1;
}
repetitions -= 1;
}
}
}

3
src/main/resources/JavaTestfiles/ClassWithField.java Normal file
View File

@ -0,0 +1,3 @@
public class ClassWithField {
int x;
}

1
src/main/resources/ClassWithMethod.java → src/main/resources/JavaTestfiles/ClassWithMethod.java
View File

@ -1,4 +1,5 @@
public class ClassWithMethod { public class ClassWithMethod {
public boolean method() { public boolean method() {
return false;
} }
} }

11
src/main/resources/JavaTestfiles/ClassWithMethodAndField.java Normal file
View File

@ -0,0 +1,11 @@
public class ClassWithMethodAndField {
char c;
public ClassWithMethodAndField(char character) {
this.c = character;
}
public boolean method() {
return true;
}
}

19
src/main/resources/JavaTestfiles/ClassWithMoreComplexMethodAndMain.java Normal file
View File

@ -0,0 +1,19 @@
public class ClassWithMoreComplexMethodAndMain {
ClassWithMoreComplexMethodAndMain instance;
public boolean moreComplexMethod() {
int i;
i = 11;
boolean returnValue;
returnValue = false;
while (i > 0) {
i -= 1;
returnValue = !returnValue;
}
return returnValue;
}
public static void main(String[] args) {
instance = new ClassWithMoreComplexMethodAndMain()
}
}

0
src/main/resources/OnlyClass.java → src/main/resources/JavaTestfiles/OnlyClass.java
View File

0
src/main/resources/PublicClass.java → src/main/resources/JavaTestfiles/PublicClass.java
View File