JavaTX/JavaCompilerCore
2
0
Fork 3
Code Issues 99 Pull Requests Actions Packages Projects Releases Wiki Activity

Records in AST aufgenommen

Browse Source
This commit is contained in:
luca9913 2023-04-01 15:40:12 +02:00
parent 9a780127c0
commit dc8578632c
14 changed files with 203 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/main/java/de/dhbwstuttgart/parser/JavaTXParser.java
View File

@ -17,8 +17,7 @@ import java.util.ArrayList;
import java.util.List; import java.util.List;
public class JavaTXParser { public class JavaTXParser {
public static Java17Parser.SourceFileContext parse(File source) public static Java17Parser.SourceFileContext parse(File source) throws IOException, java.lang.ClassNotFoundException {
throws IOException, java.lang.ClassNotFoundException {
InputStream stream = new FileInputStream(source); InputStream stream = new FileInputStream(source);
// DEPRECATED: ANTLRInputStream input = new ANTLRInputStream(stream); // DEPRECATED: ANTLRInputStream input = new ANTLRInputStream(stream);
CharStream input = CharStreams.fromStream(stream); CharStream input = CharStreams.fromStream(stream);
@ -27,19 +26,11 @@ public class JavaTXParser {
Java17Parser parser = new Java17Parser(tokens); Java17Parser parser = new Java17Parser(tokens);
return parser.sourceFile(); return parser.sourceFile();
/* /*
* SyntaxTreeGenerator generator = new * SyntaxTreeGenerator generator = new SyntaxTreeGenerator(environment.getRegistry(source)); return generator.convert(tree);
* SyntaxTreeGenerator(environment.getRegistry(source));
* return generator.convert(tree);
*/ */
} }
/* /*
* Für das Typsystem ist es notwendig, dass sich der Source in einer Datei * Für das Typsystem ist es notwendig, dass sich der Source in einer Datei befindet: public SourceFile parse(String fileContent) throws IOException, java.lang.ClassNotFoundException { return this.parse(new ByteArrayInputStream(fileContent.getBytes(StandardCharsets.UTF_8))); }
* befindet:
* public SourceFile parse(String fileContent) throws IOException,
* java.lang.ClassNotFoundException {
* return this.parse(new
* ByteArrayInputStream(fileContent.getBytes(StandardCharsets.UTF_8)));
* }
*/ */
} }

176
src/main/java/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java
View File

@ -2,6 +2,7 @@ package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
import java.lang.reflect.Modifier; import java.lang.reflect.Modifier;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap; import java.util.HashMap;
import java.util.HashSet; import java.util.HashSet;
import java.util.List; import java.util.List;
@ -14,6 +15,8 @@ import java.util.stream.Collectors;
import org.antlr.v4.runtime.CommonToken; import org.antlr.v4.runtime.CommonToken;
import org.antlr.v4.runtime.Token; import org.antlr.v4.runtime.Token;
import com.google.common.graph.ElementOrder.Type;
import de.dhbwstuttgart.environment.PackageCrawler; import de.dhbwstuttgart.environment.PackageCrawler;
import de.dhbwstuttgart.exceptions.NotImplementedException; import de.dhbwstuttgart.exceptions.NotImplementedException;
import de.dhbwstuttgart.exceptions.TypeinferenceException; import de.dhbwstuttgart.exceptions.TypeinferenceException;
@ -49,6 +52,8 @@ import de.dhbwstuttgart.parser.antlr.Java17Parser.MethodblockContext;
import de.dhbwstuttgart.parser.antlr.Java17Parser.MethoddeclContext; import de.dhbwstuttgart.parser.antlr.Java17Parser.MethoddeclContext;
import de.dhbwstuttgart.parser.antlr.Java17Parser.ModifierContext; import de.dhbwstuttgart.parser.antlr.Java17Parser.ModifierContext;
import de.dhbwstuttgart.parser.antlr.Java17Parser.NoclassorinterfaceContext; import de.dhbwstuttgart.parser.antlr.Java17Parser.NoclassorinterfaceContext;
import de.dhbwstuttgart.parser.antlr.Java17Parser.RecordComponentContext;
import de.dhbwstuttgart.parser.antlr.Java17Parser.RecordDeclarationContext;
import de.dhbwstuttgart.parser.antlr.Java17Parser.ReftypeContext; import de.dhbwstuttgart.parser.antlr.Java17Parser.ReftypeContext;
import de.dhbwstuttgart.parser.antlr.Java17Parser.SrcfileContext; import de.dhbwstuttgart.parser.antlr.Java17Parser.SrcfileContext;
import de.dhbwstuttgart.parser.antlr.Java17Parser.TypeArgumentsContext; import de.dhbwstuttgart.parser.antlr.Java17Parser.TypeArgumentsContext;
@ -59,17 +64,27 @@ import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
import de.dhbwstuttgart.syntaxtree.ClassOrInterface; import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
import de.dhbwstuttgart.syntaxtree.Constructor; import de.dhbwstuttgart.syntaxtree.Constructor;
import de.dhbwstuttgart.syntaxtree.Field; import de.dhbwstuttgart.syntaxtree.Field;
import de.dhbwstuttgart.syntaxtree.FormalParameter;
import de.dhbwstuttgart.syntaxtree.GenericDeclarationList; import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
import de.dhbwstuttgart.syntaxtree.Method; import de.dhbwstuttgart.syntaxtree.Method;
import de.dhbwstuttgart.syntaxtree.ParameterList; import de.dhbwstuttgart.syntaxtree.ParameterList;
import de.dhbwstuttgart.syntaxtree.Record;
import de.dhbwstuttgart.syntaxtree.SourceFile; import de.dhbwstuttgart.syntaxtree.SourceFile;
import de.dhbwstuttgart.syntaxtree.factory.ASTFactory; import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
import de.dhbwstuttgart.syntaxtree.statement.Assign;
import de.dhbwstuttgart.syntaxtree.statement.AssignLeftSide;
import de.dhbwstuttgart.syntaxtree.statement.AssignToField;
import de.dhbwstuttgart.syntaxtree.statement.Block; import de.dhbwstuttgart.syntaxtree.statement.Block;
import de.dhbwstuttgart.syntaxtree.statement.FieldVar;
import de.dhbwstuttgart.syntaxtree.statement.LocalVar;
import de.dhbwstuttgart.syntaxtree.statement.Return;
import de.dhbwstuttgart.syntaxtree.statement.Statement; import de.dhbwstuttgart.syntaxtree.statement.Statement;
import de.dhbwstuttgart.syntaxtree.statement.This;
import de.dhbwstuttgart.syntaxtree.type.RefType; import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.syntaxtree.type.Void; import de.dhbwstuttgart.syntaxtree.type.Void;
import de.dhbwstuttgart.typeinference.constraints.GenericsResolver;
public class SyntaxTreeGenerator { public class SyntaxTreeGenerator {
private JavaClassRegistry reg; private JavaClassRegistry reg;
@ -114,9 +129,7 @@ public class SyntaxTreeGenerator {
public String convertQualifiedName(Java17Parser.QualifiedNameContext ctx) { public String convertQualifiedName(Java17Parser.QualifiedNameContext ctx) {
/* /*
* String ret = ""; for (Java17Parser.IdentifierContext ident : * String ret = ""; for (Java17Parser.IdentifierContext ident : ctx.identifier()) { ret += ident.getText(); if (ctx.identifier().iterator().hasNext()) { ret += '.'; } }
* ctx.identifier()) { ret += ident.getText(); if
* (ctx.identifier().iterator().hasNext()) { ret += '.'; } }
*/ */
return ctx.getText(); return ctx.getText();
} }
@ -152,7 +165,8 @@ public class SyntaxTreeGenerator {
newClass = convertClass(clsoif.classDeclaration(), modifiers); newClass = convertClass(clsoif.classDeclaration(), modifiers);
} else if (!Objects.isNull(clsoif.interfaceDeclaration())) { } else if (!Objects.isNull(clsoif.interfaceDeclaration())) {
newClass = convertInterface(clsoif.interfaceDeclaration(), modifiers); newClass = convertInterface(clsoif.interfaceDeclaration(), modifiers);
// TODO: else if(!Objects.isNull(clsoif.recordDeclaration())){ } else if (!Objects.isNull(clsoif.recordDeclaration())) {
newClass = convertRecord(clsoif.recordDeclaration(), modifiers);
} else { } else {
throw new NotImplementedException(); throw new NotImplementedException();
} }
@ -196,62 +210,117 @@ public class SyntaxTreeGenerator {
List<RefType> implementedInterfaces = new ArrayList<>(); List<RefType> implementedInterfaces = new ArrayList<>();
List<RefType> permittedSubtypes = new ArrayList<>(); List<RefType> permittedSubtypes = new ArrayList<>();
for (ClassBodyDeclarationContext clsbodydecl : ctx.classBody().classBodyDeclaration()) { for (ClassBodyDeclarationContext clsbodydecl : ctx.classBody().classBodyDeclaration()) {
MemberdeclContext member; convert(clsbodydecl, fielddecl, constructors, methods, name, superClass, generics);
// Statement-Blöcke und "leere Zeilen" (;) werden noch nicht berücksichtigt }
if (clsbodydecl instanceof MemberdeclContext) { if (constructors.isEmpty()) {
member = (MemberdeclContext) clsbodydecl; constructors.add(generateStandardConstructor(ctx.identifier().getText(), name, superClass, genericClassParameters, offset));
Integer membermodifiers = 0; }
for (ModifierContext mod : member.modifier()) { if (ctx.IMPLEMENTS() != null) {
membermodifiers += allmodifiers.get(mod.getText()); implementedInterfaces.addAll(convert(ctx.typeList(0), generics));
} }
switch (member.memberDeclaration()) { // Ist Bit für 'sealed'-Modifier gesetzt
case MemberclassorinterfaceContext memberclsoif: { if ((modifiers & 4096) != 0) {
break; switch (ctx.typeList().size()) {
} case 1: {
case MemberfieldContext memberfield: { permittedSubtypes.addAll(convert(ctx.typeList(0), generics));
fielddecl.addAll(convert(memberfield.fieldDeclaration(), membermodifiers, generics)); break;
break;
}
case MembermethodContext membermethod: {
methods.add(convert(membermodifiers, membermethod.method(), name, superClass, generics));
break;
}
case MemberconstructorContext memberconstructor: {
constructors.add(convert(membermodifiers, memberconstructor.constructor(), name, superClass, generics));
break;
}
default:
break;
}
} else {
continue;
} }
if (constructors.isEmpty()) { case 2: {
constructors.add(generateStandardConstructor(ctx.identifier().getText(), name, superClass, genericClassParameters, offset)); permittedSubtypes.addAll(convert(ctx.typeList(1), generics));
break;
} }
if (ctx.IMPLEMENTS() != null) { default: {
implementedInterfaces.addAll(convert(ctx.typeList(0), generics)); break;
} }
// Ist Bit für 'sealed'-Modifier gesetzt
if ((modifiers & 4096) != 0) {
switch (ctx.typeList().size()) {
case 1: {
permittedSubtypes.addAll(convert(ctx.typeList(0), generics));
break;
}
case 2: {
permittedSubtypes.addAll(convert(ctx.typeList(1), generics));
break;
}
default: {
break;
}
}
} }
} }
return new ClassOrInterface(modifiers, name, fielddecl, Optional.of(this.generatePseudoConstructor(ctx.identifier().getText(), name, superClass, genericClassParameters, offset)), methods, constructors, genericClassParameters, superClass, isInterface, implementedInterfaces, offset); return new ClassOrInterface(modifiers, name, fielddecl, Optional.of(this.generatePseudoConstructor(ctx.identifier().getText(), name, superClass, genericClassParameters, offset)), methods, constructors, genericClassParameters, superClass, isInterface, implementedInterfaces, offset);
} }
private de.dhbwstuttgart.syntaxtree.Record convertRecord(RecordDeclarationContext recordDeclaration, int modifiers) {
String identifier = recordDeclaration.identifier().getText();
String className = this.pkgName + (this.pkgName.length() > 0 ? "." : "") + identifier;
JavaClassName name = reg.getName(className); // Holt den Package Namen mit dazu
Token offset = recordDeclaration.getStart();
GenericsRegistry generics = createGenerics(recordDeclaration.genericDeclarationList(), name, "", reg, new GenericsRegistry(globalGenerics));
if (!name.toString().equals(className)) { // Kommt die Klasse schon in einem anderen Package vor?
throw new TypeinferenceException("Name " + className + " bereits vorhanden in " + reg.getName(className).toString(), recordDeclaration.getStart());
}
GenericDeclarationList genericClassParameters;
if (recordDeclaration.genericDeclarationList() == null) {
genericClassParameters = new GenericDeclarationList(new ArrayList<>(), recordDeclaration.identifier().getStop());
} else {
genericClassParameters = TypeGenerator.convert(recordDeclaration.genericDeclarationList(), name, "", reg, generics);
}
RefType superClass = new RefType(ASTFactory.createObjectClass().getClassName(), offset);
List<Field> fielddecl = new ArrayList<>();
List<Method> methods = new ArrayList<>();
List<Constructor> constructors = new ArrayList<>();
Boolean isInterface = false;
List<RefType> implementedInterfaces = new ArrayList<>();
List<FormalParameter> constructorParameters = new ArrayList<>();
List<Statement> constructorStatements = new ArrayList<>();
for (RecordComponentContext component : recordDeclaration.recordHeader().recordComponentList().recordComponent()) {
int fieldmodifiers = allmodifiers.get("private") + allmodifiers.get("final");
String fieldname = component.identifier().getText();
Token fieldoffset = component.getStart();
RefTypeOrTPHOrWildcardOrGeneric fieldtype = null;
if (Objects.isNull(component.typeType())) {
fieldtype = TypePlaceholder.fresh(offset);
} else {
fieldtype = TypeGenerator.convert(component.typeType(), reg, generics);
}
fielddecl.add(new Field(fieldname, fieldtype, fieldmodifiers, fieldoffset));
constructorParameters.add(new FormalParameter(fieldname, fieldtype, fieldoffset));
FieldVar fieldvar = new FieldVar(new This(offset), fieldname, fieldtype, fieldoffset);
constructorStatements.add(new Assign(new AssignToField(fieldvar), new LocalVar(fieldname, fieldtype, fieldoffset), offset));
Statement returnStatement = new Return(fieldvar, offset);
methods.add(new Method(allmodifiers.get("public"), fieldname, fieldtype, new ParameterList(new ArrayList<>(), offset), new Block(Arrays.asList(returnStatement), offset), new GenericDeclarationList(new ArrayList<>(), offset), offset));
}
RefType classType = ClassOrInterface.generateTypeOfClass(reg.getName(className), genericClassParameters, offset);
Constructor implicitConstructor = new Constructor(allmodifiers.get("public"), identifier, classType, new ParameterList(constructorParameters, offset), new Block(constructorStatements, offset), genericClassParameters, offset);
Optional<Constructor> initializations = Optional.of(implicitConstructor);
constructors.add(implicitConstructor);
for (ClassBodyDeclarationContext bodyDeclaration : recordDeclaration.recordBody().classBodyDeclaration()) {
convert(bodyDeclaration, fielddecl, constructors, methods, name, superClass, generics);
}
if (!Objects.isNull(recordDeclaration.IMPLEMENTS())) {
implementedInterfaces.addAll(convert(recordDeclaration.typeList(), generics));
}
return new Record(modifiers, name, fielddecl, initializations, methods, constructors, genericClassParameters, superClass, isInterface, implementedInterfaces, offset);
}
private void convert(ClassBodyDeclarationContext classBody, List<Field> fields, List<Constructor> constructors, List<Method> methods, JavaClassName name, RefType superClass, GenericsRegistry generics) {
MemberdeclContext member;
// Statement-Blöcke und "leere Zeilen" (;) werden noch nicht berücksichtigt
if (classBody instanceof MemberdeclContext) {
member = (MemberdeclContext) classBody;
Integer membermodifiers = 0;
for (ModifierContext mod : member.modifier()) {
membermodifiers += allmodifiers.get(mod.getText());
}
switch (member.memberDeclaration()) {
case MemberclassorinterfaceContext memberclsoif: {
break;
}
case MemberfieldContext memberfield: {
fields.addAll(convert(memberfield.fieldDeclaration(), membermodifiers, generics));
break;
}
case MembermethodContext membermethod: {
methods.add(convert(membermodifiers, membermethod.method(), name, superClass, generics));
break;
}
case MemberconstructorContext memberconstructor: {
constructors.add(convert(membermodifiers, memberconstructor.constructor(), name, superClass, generics));
break;
}
default:
break;
}
}
}
private ClassOrInterface convertInterface(Java17Parser.InterfaceDeclarationContext ctx, int modifiers) { private ClassOrInterface convertInterface(Java17Parser.InterfaceDeclarationContext ctx, int modifiers) {
String className = this.pkgName.length() > 0 ? this.pkgName + "." : "" + ctx.identifier().getText(); String className = this.pkgName.length() > 0 ? this.pkgName + "." : "" + ctx.identifier().getText();
JavaClassName name = reg.getName(className); // Holt den Package Namen mit dazu JavaClassName name = reg.getName(className); // Holt den Package Namen mit dazu
@ -368,8 +437,7 @@ public class SyntaxTreeGenerator {
} }
/* /*
* fieldInitializations werden in einem Psedokonstruktor in der abstrakten * fieldInitializations werden in einem Psedokonstruktor in der abstrakten Syntax gespeichert
* Syntax gespeichert
*/ */
private Constructor generatePseudoConstructor(String className, JavaClassName parentClass, RefType superClass, GenericDeclarationList classGenerics, Token offset) { private Constructor generatePseudoConstructor(String className, JavaClassName parentClass, RefType superClass, GenericDeclarationList classGenerics, Token offset) {
RefType classType = ClassOrInterface.generateTypeOfClass(reg.getName(className), classGenerics, offset); RefType classType = ClassOrInterface.generateTypeOfClass(reg.getName(className), classGenerics, offset);

59
src/main/java/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java
View File

@ -32,20 +32,11 @@ public class TypeGenerator {
public static RefTypeOrTPHOrWildcardOrGeneric convert(Java17Parser.ClassOrInterfaceTypeContext classOrInterfaceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) { public static RefTypeOrTPHOrWildcardOrGeneric convert(Java17Parser.ClassOrInterfaceTypeContext classOrInterfaceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) {
Java17Parser.TypeArgumentsContext arguments = null; Java17Parser.TypeArgumentsContext arguments = null;
/* /*
* PL 2019-03-19 auskommentiert ANFANG if(unannClassOrInterfaceTypeContext. * PL 2019-03-19 auskommentiert ANFANG if(unannClassOrInterfaceTypeContext. unannClassType_lfno_unannClassOrInterfaceType() != null){ arguments = unannClassOrInterfaceTypeContext. unannClassType_lfno_unannClassOrInterfaceType().typeArguments(); }else{// if(unannClassOrInterfaceTypeContext. unannInterfaceType_lfno_unannClassOrInterfaceType() != null){ arguments = unannClassOrInterfaceTypeContext. unannInterfaceType_lfno_unannClassOrInterfaceType().
* unannClassType_lfno_unannClassOrInterfaceType() != null){ arguments = * unannClassType_lfno_unannClassOrInterfaceType().typeArguments(); } PL 2019-03-19 auskommentiert ENDE
* unannClassOrInterfaceTypeContext.
* unannClassType_lfno_unannClassOrInterfaceType().typeArguments(); }else{//
* if(unannClassOrInterfaceTypeContext.
* unannInterfaceType_lfno_unannClassOrInterfaceType() != null){ arguments =
* unannClassOrInterfaceTypeContext.
* unannInterfaceType_lfno_unannClassOrInterfaceType().
* unannClassType_lfno_unannClassOrInterfaceType().typeArguments(); } PL
* 2019-03-19 auskommentiert ENDE
*/ */
/** /**
* Problem sind hier die verschachtelten Typen mit verschachtelten Typargumenten * Problem sind hier die verschachtelten Typen mit verschachtelten Typargumenten Beispiel: Typ<String>.InnererTyp<Integer>
* Beispiel: Typ<String>.InnererTyp<Integer>
*/ */
if (classOrInterfaceTypeContext.typeArguments().size() > 1) if (classOrInterfaceTypeContext.typeArguments().size() > 1)
throw new NotImplementedException(); throw new NotImplementedException();
@ -57,31 +48,9 @@ public class TypeGenerator {
name += classOrInterfaceTypeContext.typeIdentifier().getText(); name += classOrInterfaceTypeContext.typeIdentifier().getText();
if (classOrInterfaceTypeContext.getStop().getText().equals(">")) { if (classOrInterfaceTypeContext.getStop().getText().equals(">")) {
/* /*
* Fuer Debug-Zwecke unannClassOrInterfaceTypeContext. * Fuer Debug-Zwecke unannClassOrInterfaceTypeContext. unannInterfaceType_lfno_unannClassOrInterfaceType(); unannClassOrInterfaceTypeContext. unannClassType_lfno_unannClassOrInterfaceType().getText(); //unannClassOrInterfaceTypeContext. unannInterfaceType_lfno_unannClassOrInterfaceType(). unannClassType_lfno_unannClassOrInterfaceType().typeArguments(); //UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType( 0);
* unannInterfaceType_lfno_unannClassOrInterfaceType(); * unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType( 0).getText(); unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType( 1); unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType( 1).getText(); unannClassOrInterfaceTypeContext. unannClassType_lfno_unannClassOrInterfaceType().getText(); //unannClassOrInterfaceTypeContext. unannInterfaceType_lf_unannClassOrInterfaceType(); //unannClassOrInterfaceTypeContext.
* unannClassOrInterfaceTypeContext. * unannInterfaceType_lf_unannClassOrInterfaceType(0).getText(); //unannClassOrInterfaceTypeContext. unannInterfaceType_lf_unannClassOrInterfaceType(1).getText(); //unannClassOrInterfaceTypeContext. unannInterfaceType_lfno_unannClassOrInterfaceType().getText();
* unannClassType_lfno_unannClassOrInterfaceType().getText();
* //unannClassOrInterfaceTypeContext.
* unannInterfaceType_lfno_unannClassOrInterfaceType().
* unannClassType_lfno_unannClassOrInterfaceType().typeArguments();
* //UnannClassType_lfno_unannClassOrInterfaceTypeContext
* unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(
* 0);
* unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(
* 0).getText();
* unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(
* 1);
* unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(
* 1).getText(); unannClassOrInterfaceTypeContext.
* unannClassType_lfno_unannClassOrInterfaceType().getText();
* //unannClassOrInterfaceTypeContext.
* unannInterfaceType_lf_unannClassOrInterfaceType();
* //unannClassOrInterfaceTypeContext.
* unannInterfaceType_lf_unannClassOrInterfaceType(0).getText();
* //unannClassOrInterfaceTypeContext.
* unannInterfaceType_lf_unannClassOrInterfaceType(1).getText();
* //unannClassOrInterfaceTypeContext.
* unannInterfaceType_lfno_unannClassOrInterfaceType().getText();
*/ */
List<TypeArgumentsContext> typeargs = classOrInterfaceTypeContext.typeArguments(); List<TypeArgumentsContext> typeargs = classOrInterfaceTypeContext.typeArguments();
arguments = typeargs.size() != 0 ? classOrInterfaceTypeContext.typeArguments(0) : null; arguments = typeargs.size() != 0 ? classOrInterfaceTypeContext.typeArguments(0) : null;
@ -91,14 +60,12 @@ public class TypeGenerator {
public static RefTypeOrTPHOrWildcardOrGeneric convert(Java17Parser.TypeTypeContext typeContext, JavaClassRegistry reg, GenericsRegistry genericsRegistry) { public static RefTypeOrTPHOrWildcardOrGeneric convert(Java17Parser.TypeTypeContext typeContext, JavaClassRegistry reg, GenericsRegistry genericsRegistry) {
if (typeContext.primitiveType() != null) { if (typeContext.primitiveType() != null) {
if (typeContext.primitiveType().getText().equals("boolean")) { switch (typeContext.primitiveType().getText()) {
case "boolean":
return new RefType(ASTFactory.createClass(Boolean.class).getClassName(), typeContext.getStart()); return new RefType(ASTFactory.createClass(Boolean.class).getClassName(), typeContext.getStart());
} else { case "int":
/* return new RefType(ASTFactory.createClass(Integer.class).getClassName(), typeContext.getStart());
* Nicht benötigt, wenn danach eine Exception erstellt wird default:
* Java17Parser.NumericTypeContext numericType =
* typeContext.unannPrimitiveType().numericType();
*/
throw new NotImplementedException(); throw new NotImplementedException();
} }
} else if (!typeContext.LBRACK().isEmpty()) { // ArrayType über eckige Klammer prüfen } else if (!typeContext.LBRACK().isEmpty()) { // ArrayType über eckige Klammer prüfen
@ -106,9 +73,7 @@ public class TypeGenerator {
throw new NotImplementedException(); throw new NotImplementedException();
} }
/* /*
* else if (typeContext.classOrInterfaceType() != null) { JavaClassName name = * else if (typeContext.classOrInterfaceType() != null) { JavaClassName name = reg .getName(typeContext.classOrInterfaceType().typeIdentifier().getText()); return new RefType(name, typeContext.getStart()); }
* reg .getName(typeContext.classOrInterfaceType().typeIdentifier().getText());
* return new RefType(name, typeContext.getStart()); }
*/ */
return TypeGenerator.convert(typeContext.classOrInterfaceType(), reg, genericsRegistry); return TypeGenerator.convert(typeContext.classOrInterfaceType(), reg, genericsRegistry);
} }

14
src/main/java/de/dhbwstuttgart/syntaxtree/Constructor.java
View File

@ -12,20 +12,16 @@ import java.util.List;
public class Constructor extends Method { public class Constructor extends Method {
// TODO: Constructor braucht ein super-Statement
//TODO: Constructor braucht ein super-Statement public Constructor(int modifier, String name, RefTypeOrTPHOrWildcardOrGeneric returnType, ParameterList parameterList, Block codeInsideConstructor, GenericDeclarationList gtvDeclarations, Token offset /* , List<Statement> fieldInitializations geloescht PL 2018-11-24 */) {
public Constructor(int modifier, String name, RefTypeOrTPHOrWildcardOrGeneric returnType, ParameterList parameterList, Block codeInsideConstructor, super(modifier, name, returnType, parameterList, /* codeInsideConstructor, */ prepareBlock(codeInsideConstructor) /* ,fieldInitializations )geloescht PL 2018-11-24 ) */, gtvDeclarations, offset);
GenericDeclarationList gtvDeclarations, Token offset /*, List<Statement> fieldInitializations geloescht PL 2018-11-24 */) {
super(modifier, name, returnType, parameterList, /*codeInsideConstructor,*/ prepareBlock(codeInsideConstructor ) /*,fieldInitializations )geloescht PL 2018-11-24 )*/, gtvDeclarations, offset);
} }
/** /**
* @param fieldInitializations - Das sind die Statements, * @param fieldInitializations - Das sind die Statements, welche die Felder der zugehörigen Klasse dieses Konstruktor initialisieren
* welche die Felder der zugehörigen Klasse dieses
* Konstruktor initialisieren
*/ */
protected static Block prepareBlock(Block constructorBlock /*, List<Statement> fieldInitializations new ArrayList<>() geloescht PL 2018-11-24 */){ protected static Block prepareBlock(Block constructorBlock /* , List<Statement> fieldInitializations new ArrayList<>() geloescht PL 2018-11-24 */) {
List<Statement> statements = constructorBlock.getStatements(); List<Statement> statements = constructorBlock.getStatements();
statements.add(0, new SuperCall(null, null, constructorBlock.getOffset())); statements.add(0, new SuperCall(null, null, constructorBlock.getOffset()));
/* statements.addAll(fieldInitializations); geloescht PL 2018-11-24 */ /* statements.addAll(fieldInitializations); geloescht PL 2018-11-24 */

13
src/main/java/de/dhbwstuttgart/syntaxtree/Field.java
View File

@ -5,22 +5,22 @@ import org.antlr.v4.runtime.Token;
import java.util.ArrayList; import java.util.ArrayList;
public class Field extends SyntaxTreeNode implements TypeScope{ public class Field extends SyntaxTreeNode implements TypeScope {
public final int modifier; public final int modifier;
private String name; private String name;
private RefTypeOrTPHOrWildcardOrGeneric type; private RefTypeOrTPHOrWildcardOrGeneric type;
public Field(String name, RefTypeOrTPHOrWildcardOrGeneric type, int modifier, Token offset){ public Field(String name, RefTypeOrTPHOrWildcardOrGeneric type, int modifier, Token offset) {
super(offset); super(offset);
this.name = name; this.name = name;
this.type = type; this.type = type;
this.modifier = modifier; this.modifier = modifier;
} }
public String getName(){ public String getName() {
return this.name; return this.name;
} }
public RefTypeOrTPHOrWildcardOrGeneric getType() { public RefTypeOrTPHOrWildcardOrGeneric getType() {
return type; return type;
@ -41,4 +41,3 @@ public class Field extends SyntaxTreeNode implements TypeScope{
return type; return type;
} }
} }

9
src/main/java/de/dhbwstuttgart/syntaxtree/FormalParameter.java
View File

@ -3,15 +3,14 @@ package de.dhbwstuttgart.syntaxtree;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
import org.antlr.v4.runtime.Token; import org.antlr.v4.runtime.Token;
public class FormalParameter extends SyntaxTreeNode public class FormalParameter extends SyntaxTreeNode {
{
private RefTypeOrTPHOrWildcardOrGeneric type; private RefTypeOrTPHOrWildcardOrGeneric type;
private String name; private String name;
public FormalParameter(String name, RefTypeOrTPHOrWildcardOrGeneric type, Token offset){ public FormalParameter(String name, RefTypeOrTPHOrWildcardOrGeneric type, Token offset) {
super(offset); super(offset);
this.name = name; this.name = name;
this.type = type; this.type = type;
} }
public RefTypeOrTPHOrWildcardOrGeneric getType() { public RefTypeOrTPHOrWildcardOrGeneric getType() {

32
src/main/java/de/dhbwstuttgart/syntaxtree/ParameterList.java
View File

@ -1,39 +1,33 @@
package de.dhbwstuttgart.syntaxtree; package de.dhbwstuttgart.syntaxtree;
import org.antlr.v4.runtime.Token; import org.antlr.v4.runtime.Token;
import java.util.Iterator; import java.util.Iterator;
import java.util.List; import java.util.List;
public class ParameterList extends SyntaxTreeNode implements Iterable<FormalParameter> {
public class ParameterList extends SyntaxTreeNode implements Iterable<FormalParameter>
{
private List<FormalParameter> formalparameter; private List<FormalParameter> formalparameter;
public ParameterList(List<FormalParameter> params, Token offset){ public ParameterList(List<FormalParameter> params, Token offset) {
super(offset); super(offset);
this.formalparameter = params; this.formalparameter = params;
} }
public FormalParameter getParameterAt(int i) public FormalParameter getParameterAt(int i) {
{ if (i >= formalparameter.size())
if (i >= formalparameter.size() ) return null; return null;
return formalparameter.get(i); return formalparameter.get(i);
} }
public List<FormalParameter> getFormalparalist() {
public List<FormalParameter> getFormalparalist()
{
return formalparameter; return formalparameter;
} }
@Override @Override
public Iterator<FormalParameter> iterator() { public Iterator<FormalParameter> iterator() {
return formalparameter.iterator(); return formalparameter.iterator();
} }
@Override @Override
public void accept(ASTVisitor visitor) { public void accept(ASTVisitor visitor) {

16
src/main/java/de/dhbwstuttgart/syntaxtree/Record.java Normal file
View File

@ -0,0 +1,16 @@
package de.dhbwstuttgart.syntaxtree;
import java.util.List;
import java.util.Optional;
import org.antlr.v4.runtime.Token;
import de.dhbwstuttgart.parser.scope.JavaClassName;
import de.dhbwstuttgart.syntaxtree.type.RefType;
public class Record extends ClassOrInterface {
public Record(int modifiers, JavaClassName name, List<Field> fielddecl, Optional<Constructor> fieldInitializations, List<Method> methods, List<Constructor> constructors, GenericDeclarationList genericClassParameters, RefType superClass, Boolean isInterface, List<RefType> implementedInterfaces, Token offset) {
super(modifiers, name, fielddecl, fieldInitializations, methods, constructors, genericClassParameters, superClass, isInterface, implementedInterfaces, offset);
}
}

7
src/main/java/de/dhbwstuttgart/syntaxtree/statement/Assign.java
View File

@ -11,16 +11,15 @@ import org.antlr.v4.runtime.Token;
Aufbau: Aufbau:
rightSide = leftSide rightSide = leftSide
*/ */
public class Assign extends Statement public class Assign extends Statement {
{
public final Expression rightSide; public final Expression rightSide;
public final AssignLeftSide lefSide; public final AssignLeftSide lefSide;
public Assign(AssignLeftSide leftHandSide, Expression value, Token offset) { public Assign(AssignLeftSide leftHandSide, Expression value, Token offset) {
super(leftHandSide.getType(), offset); super(leftHandSide.getType(), offset);
this.rightSide = value; this.rightSide = value;
this.lefSide = leftHandSide; this.lefSide = leftHandSide;
} }
@Override @Override
public void accept(StatementVisitor visitor) { public void accept(StatementVisitor visitor) {

3
src/main/java/de/dhbwstuttgart/syntaxtree/statement/AssignToField.java
View File

@ -2,8 +2,9 @@ package de.dhbwstuttgart.syntaxtree.statement;
import de.dhbwstuttgart.syntaxtree.StatementVisitor; import de.dhbwstuttgart.syntaxtree.StatementVisitor;
public class AssignToField extends AssignLeftSide{ public class AssignToField extends AssignLeftSide {
public final FieldVar field; public final FieldVar field;
public AssignToField(FieldVar fieldVar) { public AssignToField(FieldVar fieldVar) {
super(fieldVar.getType(), fieldVar.getOffset()); super(fieldVar.getType(), fieldVar.getOffset());
field = fieldVar; field = fieldVar;

13
src/main/java/de/dhbwstuttgart/syntaxtree/statement/BinaryExpr.java
View File

@ -1,24 +1,22 @@
package de.dhbwstuttgart.syntaxtree.statement; package de.dhbwstuttgart.syntaxtree.statement;
import de.dhbwstuttgart.syntaxtree.StatementVisitor; import de.dhbwstuttgart.syntaxtree.StatementVisitor;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
import org.antlr.v4.runtime.Token; import org.antlr.v4.runtime.Token;
public class BinaryExpr extends Expression public class BinaryExpr extends Expression {
{
@Override @Override
public void accept(StatementVisitor visitor) { public void accept(StatementVisitor visitor) {
visitor.visit(this); visitor.visit(this);
} }
public enum Operator{ public enum Operator {
ADD, // + ADD, // +
SUB, // - SUB, // -
MUL, // * MUL, // *
MOD, // Modulo Operator % MOD, // Modulo Operator %
AND, // && AND, // &&
OR, // || OR, // ||
DIV, // / DIV, // /
LESSTHAN, // < LESSTHAN, // <
BIGGERTHAN, // > BIGGERTHAN, // >
@ -32,9 +30,8 @@ public class BinaryExpr extends Expression
public final Expression lexpr; public final Expression lexpr;
public final Expression rexpr; public final Expression rexpr;
public BinaryExpr(Operator operation, RefTypeOrTPHOrWildcardOrGeneric type, Expression lexpr, Expression rexpr, Token offset) public BinaryExpr(Operator operation, RefTypeOrTPHOrWildcardOrGeneric type, Expression lexpr, Expression rexpr, Token offset) {
{ super(type, offset);
super(type,offset);
this.operation = operation; this.operation = operation;
this.lexpr = lexpr; this.lexpr = lexpr;

9
src/main/java/de/dhbwstuttgart/syntaxtree/statement/InstanceOf.java
View File

@ -4,14 +4,11 @@ import de.dhbwstuttgart.exceptions.NotImplementedException;
import de.dhbwstuttgart.syntaxtree.StatementVisitor; import de.dhbwstuttgart.syntaxtree.StatementVisitor;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
public class InstanceOf extends BinaryExpr {
public class InstanceOf extends BinaryExpr
{
public Expression expr; public Expression expr;
private RefTypeOrTPHOrWildcardOrGeneric reftype; private RefTypeOrTPHOrWildcardOrGeneric reftype;
public InstanceOf(int offset,int variableLength) public InstanceOf(int offset, int variableLength) {
{
super(null, null, null, null, null); super(null, null, null, null, null);
throw new NotImplementedException(); throw new NotImplementedException();
// #JB# 20.04.2005 // #JB# 20.04.2005

12
src/main/java/de/dhbwstuttgart/syntaxtree/statement/LocalVar.java
View File

@ -4,19 +4,17 @@ import de.dhbwstuttgart.syntaxtree.StatementVisitor;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
import org.antlr.v4.runtime.Token; import org.antlr.v4.runtime.Token;
public class LocalVar extends Statement{ public class LocalVar extends Statement {
public final String name; public final String name;
public LocalVar(String n, RefTypeOrTPHOrWildcardOrGeneric type, Token offset) public LocalVar(String n, RefTypeOrTPHOrWildcardOrGeneric type, Token offset) {
{ super(type, offset);
super(type,offset);
this.name = n; this.name = n;
} }
public LocalVar(Expression e1, RefTypeOrTPHOrWildcardOrGeneric type, String access) public LocalVar(Expression e1, RefTypeOrTPHOrWildcardOrGeneric type, String access) {
{ super(type, e1.getOffset());
super(type,e1.getOffset());
this.name = access; this.name = access;
} }

10
src/test/java/parser/NestedPattern.jav
View File

@ -1,18 +1,16 @@
import java.lang.String; import java.lang.String;
record Point(int x, int y) {} record Point(int x, int y) {}
enum Color { RED, GREEN, BLUE }
interface Shape {} interface Shape {}
record ColoredPoint(Point pt, Color color) {} record Rectangle(Point upperLeft, Point lowerRight) implements Shape {}
record Rectangle(ColoredPoint upperLeft, ColoredPoint lowerRight) implements Shape {}
class PatternMatching { class PatternMatching {
void printColorOfUpperLeftPoint(Shape shape) void printCoordinatesOfUpperLeftPoint(Shape shape)
{ {
switch (shape) { switch (shape) {
case Rectangle(ColoredPoint(Point pt, Color color), ColoredPoint lowerRight) -> System.out.println("x: " + pt.x() + " / color: " + color + " / lowerRight: " + lowerRight); case Rectangle(Point(int x, int y), Point lowerRight) -> System.out.println("x: " + x + " / y: " + y + " / lowerRight: " + lowerRight);
default -> System.out.println("not a rectangle"); default -> System.out.println("not a rectangle");
} }
} }
} }