2017-03-15 15:17:07 +00:00
|
|
|
package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
|
|
|
|
|
2017-03-17 14:48:06 +00:00
|
|
|
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
2017-04-20 15:15:52 +00:00
|
|
|
import de.dhbwstuttgart.parser.ClassNotFoundException;
|
2017-03-15 15:17:07 +00:00
|
|
|
import de.dhbwstuttgart.parser.PackageCrawler;
|
|
|
|
import de.dhbwstuttgart.parser.antlr.Java8Parser;
|
|
|
|
import de.dhbwstuttgart.syntaxtree.*;
|
2017-03-17 14:48:06 +00:00
|
|
|
import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
|
2017-03-15 15:17:07 +00:00
|
|
|
import de.dhbwstuttgart.syntaxtree.statement.*;
|
2017-03-17 14:48:06 +00:00
|
|
|
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
2017-03-16 19:02:53 +00:00
|
|
|
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
2017-03-22 15:16:38 +00:00
|
|
|
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
2017-03-15 15:17:07 +00:00
|
|
|
import de.dhbwstuttgart.typecheck.*;
|
|
|
|
|
2017-05-18 11:17:52 +00:00
|
|
|
import java.io.File;
|
2017-03-15 15:17:07 +00:00
|
|
|
import java.lang.reflect.Modifier;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import java.util.HashMap;
|
|
|
|
import java.util.List;
|
|
|
|
|
2017-05-05 14:20:12 +00:00
|
|
|
import jdk.internal.dynalink.support.TypeConverterFactory;
|
2017-03-15 15:17:07 +00:00
|
|
|
import org.antlr.v4.runtime.Token;
|
|
|
|
import org.antlr.v4.runtime.tree.TerminalNode;
|
|
|
|
|
|
|
|
public class SyntaxTreeGenerator{
|
|
|
|
private JavaClassRegistry reg;
|
|
|
|
private String pkgName = "";
|
|
|
|
List<JavaClassName> imports = new ArrayList();
|
2017-03-22 15:05:59 +00:00
|
|
|
|
2017-03-15 15:17:07 +00:00
|
|
|
public SyntaxTreeGenerator(JavaClassRegistry reg){
|
|
|
|
this.reg = reg;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void setPackageName(Java8Parser.CompilationUnitContext ctx){
|
|
|
|
if(ctx.packageDeclaration() != null){
|
|
|
|
for(TerminalNode t : ctx.packageDeclaration().Identifier()){
|
|
|
|
this.pkgName = this.pkgName + "." + t.toString();
|
|
|
|
}
|
|
|
|
this.pkgName = this.pkgName.substring(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void getNames(Java8Parser.CompilationUnitContext ctx){
|
|
|
|
if(this.pkgName == "") this.setPackageName(ctx);
|
|
|
|
String nameString = "";
|
|
|
|
for (Java8Parser.TypeDeclarationContext typeDecl : ctx.typeDeclaration()){
|
|
|
|
if(typeDecl.interfaceDeclaration() != null){
|
|
|
|
if(typeDecl.interfaceDeclaration().normalInterfaceDeclaration() != null){
|
|
|
|
if(this.pkgName != ""){
|
|
|
|
nameString = this.pkgName + "." + typeDecl.interfaceDeclaration().normalInterfaceDeclaration().Identifier().toString();
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
nameString = typeDecl.interfaceDeclaration().normalInterfaceDeclaration().Identifier().toString();
|
|
|
|
}
|
2017-03-22 15:05:59 +00:00
|
|
|
//Die Generic TypeParameter Definitionen Nicht! an die JavaClassName-Registry anfügen:
|
2017-05-05 14:20:12 +00:00
|
|
|
/* //Diese gelängen dadurch in den globalen Scope, was sie schließlich nicht sind
|
2017-03-15 15:17:07 +00:00
|
|
|
if(typeDecl.classDeclaration().normalClassDeclaration().typeParameters() != null){
|
|
|
|
for(Java8Parser.TypeParameterContext tp : typeDecl.classDeclaration().normalClassDeclaration().typeParameters().typeParameterList().typeParameter()){
|
2017-03-22 15:05:59 +00:00
|
|
|
//this.reg.add(tp.Identifier().toString());
|
2017-03-15 15:17:07 +00:00
|
|
|
}
|
|
|
|
}
|
2017-05-05 14:20:12 +00:00
|
|
|
*/
|
2017-03-15 15:17:07 +00:00
|
|
|
this.reg.add(nameString);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
if(typeDecl.classDeclaration().normalClassDeclaration() != null){
|
|
|
|
if(this.pkgName != ""){
|
|
|
|
nameString = this.pkgName + "." + typeDecl.classDeclaration().normalClassDeclaration().Identifier().toString();
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
nameString = typeDecl.classDeclaration().normalClassDeclaration().Identifier().toString();
|
|
|
|
}
|
2017-05-05 14:20:12 +00:00
|
|
|
//Die Generic TypeParameter Definitionen Nicht! an die JavaClassName-Registry anfügen:
|
|
|
|
/* //Diese gelängen dadurch in den globalen Scope, was sie schließlich nicht sind
|
2017-03-15 15:17:07 +00:00
|
|
|
if(typeDecl.classDeclaration().normalClassDeclaration().typeParameters() != null){
|
|
|
|
for(Java8Parser.TypeParameterContext tp : typeDecl.classDeclaration().normalClassDeclaration().typeParameters().typeParameterList().typeParameter()){
|
|
|
|
this.reg.add(tp.Identifier().toString());
|
|
|
|
}
|
|
|
|
}
|
2017-05-05 14:20:12 +00:00
|
|
|
*/
|
2017-03-15 15:17:07 +00:00
|
|
|
this.reg.add(nameString);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public JavaClassRegistry getReg(){
|
|
|
|
return this.reg;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Converts type name to String.
|
|
|
|
public String convertTypeName(Java8Parser.TypeNameContext ctx){
|
|
|
|
String ret;
|
|
|
|
if(ctx.packageOrTypeName() == null){
|
|
|
|
ret = ctx.Identifier().toString();
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
ret = convertPackageOrTypeName(ctx.packageOrTypeName()) + "." + ctx.Identifier().toString();
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Converts PackageOrTypeName to String.
|
|
|
|
public String convertPackageOrTypeName(Java8Parser.PackageOrTypeNameContext ctx){
|
|
|
|
String ret;
|
|
|
|
if(ctx.packageOrTypeName() == null){
|
|
|
|
ret = ctx.Identifier().toString();
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
ret = convertPackageOrTypeName(ctx.packageOrTypeName()) + "." + ctx.Identifier().toString();
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-04-20 15:15:52 +00:00
|
|
|
public void setImports(Java8Parser.CompilationUnitContext ctx) throws ClassNotFoundException {
|
2017-03-15 15:17:07 +00:00
|
|
|
List<JavaClassName> newImports = new ArrayList();
|
|
|
|
for(Java8Parser.ImportDeclarationContext importDeclCtx : ctx.importDeclaration()){
|
|
|
|
if(importDeclCtx.singleTypeImportDeclaration() != null){
|
|
|
|
newImports.add(convertSingleTypeImportDeclaration(importDeclCtx.singleTypeImportDeclaration()));
|
|
|
|
}
|
|
|
|
else if(importDeclCtx.typeImportOnDemandDeclaration() != null){
|
|
|
|
newImports.add(convertTypeImportOnDemandDeclaration(importDeclCtx.typeImportOnDemandDeclaration()));
|
|
|
|
}
|
|
|
|
else if(importDeclCtx.singleStaticImportDeclaration() != null){
|
|
|
|
newImports.add(convertSingleStaticImportDeclaration(importDeclCtx.singleStaticImportDeclaration()));
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
newImports.add(convertStaticImportOnDemandDeclaration(importDeclCtx.staticImportOnDemandDeclaration()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
this.imports.addAll(newImports);
|
|
|
|
}
|
|
|
|
|
2017-04-20 15:15:52 +00:00
|
|
|
private JavaClassName convertSingleTypeImportDeclaration(Java8Parser.SingleTypeImportDeclarationContext ctx) throws ClassNotFoundException{
|
2017-03-15 15:17:07 +00:00
|
|
|
String typeName = convertTypeName(ctx.typeName());
|
|
|
|
String packageName = getPackageFromClass(typeName);
|
|
|
|
List<JavaClassName> classes = PackageCrawler.getClassNames(packageName);
|
|
|
|
reg.add(typeName);
|
|
|
|
JavaClassName ret = reg.getName(typeName);
|
|
|
|
if(classes.contains(ret)){
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
else{
|
2017-04-20 15:15:52 +00:00
|
|
|
throw new ClassNotFoundException();
|
2017-03-15 15:17:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private JavaClassName convertTypeImportOnDemandDeclaration(Java8Parser.TypeImportOnDemandDeclarationContext ctx){
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
private JavaClassName convertSingleStaticImportDeclaration(Java8Parser.SingleStaticImportDeclarationContext ctx){
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
private JavaClassName convertStaticImportOnDemandDeclaration(Java8Parser.StaticImportOnDemandDeclarationContext ctx){
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
private String getPackageFromClass(String cls){
|
|
|
|
String ret = "";
|
|
|
|
String[] parts = cls.split("\\.");
|
|
|
|
for(int i = 0; i < parts.length - 1; i++){
|
|
|
|
ret = ret + "." + parts[i];
|
|
|
|
}
|
|
|
|
ret = ret.substring(1);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-05-18 11:17:52 +00:00
|
|
|
public SourceFile convert(Java8Parser.CompilationUnitContext ctx, File parsedFile) throws ClassNotFoundException{
|
2017-03-15 15:17:07 +00:00
|
|
|
List<ClassOrInterface> classes = new ArrayList<>();
|
|
|
|
this.getNames(ctx);
|
2017-04-20 15:15:52 +00:00
|
|
|
this.setImports(ctx);
|
2017-03-15 15:17:07 +00:00
|
|
|
for(Java8Parser.TypeDeclarationContext typeDecl : ctx.typeDeclaration()){
|
|
|
|
ClassOrInterface newClass;
|
|
|
|
if(typeDecl.classDeclaration() != null){
|
|
|
|
newClass = convertClass(typeDecl.classDeclaration());
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
newClass = convertInterface(typeDecl.interfaceDeclaration());
|
|
|
|
}
|
|
|
|
classes.add(newClass);
|
|
|
|
}
|
2017-05-18 11:17:52 +00:00
|
|
|
return new SourceFile(parsedFile, this.pkgName, classes, this.imports);
|
2017-03-15 15:17:07 +00:00
|
|
|
}
|
|
|
|
|
2017-05-05 14:20:12 +00:00
|
|
|
public Method convert(Java8Parser.MethodDeclarationContext methodDeclarationContext, JavaClassName parentClass, GenericsRegistry generics) {
|
|
|
|
Java8Parser.MethodHeaderContext header = methodDeclarationContext.methodHeader();
|
|
|
|
int modifiers = SyntaxTreeGenerator.convert(methodDeclarationContext.methodModifier());
|
|
|
|
GenericsRegistry localGenerics = createGenerics(methodDeclarationContext.methodHeader().typeParameters(),
|
|
|
|
parentClass, header.methodDeclarator().Identifier().getText());
|
|
|
|
localGenerics.putAll(generics);
|
|
|
|
return convert(modifiers, header, methodDeclarationContext.methodBody(),parentClass, localGenerics);
|
|
|
|
}
|
|
|
|
|
|
|
|
public Method convert(Java8Parser.InterfaceMethodDeclarationContext ctx, JavaClassName parentClass, GenericsRegistry generics) {
|
|
|
|
Java8Parser.MethodHeaderContext header = ctx.methodHeader();
|
|
|
|
int modifiers = SyntaxTreeGenerator.convertInterfaceModifier(ctx.interfaceMethodModifier());
|
|
|
|
|
|
|
|
GenericsRegistry localGenerics = createGenerics(header.typeParameters(), parentClass, header.methodDeclarator().Identifier().getText());
|
|
|
|
localGenerics.putAll(generics);
|
|
|
|
|
|
|
|
return convert(modifiers, header, ctx.methodBody(),parentClass, localGenerics);
|
|
|
|
}
|
|
|
|
|
|
|
|
private Method convert(int modifiers, Java8Parser.MethodHeaderContext header, Java8Parser.MethodBodyContext body,
|
|
|
|
JavaClassName parentClass, GenericsRegistry localGenerics) {
|
|
|
|
|
|
|
|
StatementGenerator stmtGen = new StatementGenerator(reg, localGenerics);
|
|
|
|
|
|
|
|
String name = header.methodDeclarator().Identifier().getText();
|
|
|
|
GenericDeclarationList gtvDeclarations = new GenericDeclarationList(new ArrayList<>(), header.getStart());
|
|
|
|
if(header.typeParameters() != null){
|
|
|
|
gtvDeclarations = TypeGenerator.convert(header.typeParameters(), parentClass, name,reg, localGenerics);
|
|
|
|
}
|
|
|
|
RefTypeOrTPHOrWildcardOrGeneric retType;
|
|
|
|
if(header.result() != null){
|
|
|
|
if(header.result().unannType() != null){
|
|
|
|
retType = TypeGenerator.convert(header.result().unannType(), reg, localGenerics);
|
|
|
|
}
|
|
|
|
else retType = new de.dhbwstuttgart.syntaxtree.type.Void(header.result().getStart());
|
|
|
|
}else{
|
|
|
|
retType = TypePlaceholder.fresh(header.getStart());
|
|
|
|
}
|
|
|
|
ParameterList parameterList = stmtGen.convert(header.methodDeclarator().formalParameterList());
|
|
|
|
Block block = null;
|
|
|
|
if(body.block() == null){
|
|
|
|
if(! Modifier.isAbstract(modifiers)){
|
|
|
|
//TODO: Error! Abstrakte Methode ohne abstrakt Keyword
|
|
|
|
}
|
|
|
|
}else{
|
|
|
|
block = stmtGen.convert(body.block());
|
|
|
|
}
|
|
|
|
if(parentClass.equals(new JavaClassName(name))){
|
|
|
|
return new Constructor(name, retType, modifiers, parameterList, block, gtvDeclarations, header.getStart());
|
|
|
|
}else{
|
|
|
|
return new Method(name, retType, modifiers, parameterList,block, gtvDeclarations, header.getStart());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-15 15:17:07 +00:00
|
|
|
private ClassOrInterface convertClass(Java8Parser.ClassDeclarationContext ctx) {
|
|
|
|
ClassOrInterface newClass;
|
|
|
|
if(ctx.normalClassDeclaration() != null){
|
|
|
|
newClass = convertNormal(ctx.normalClassDeclaration());
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
newClass = convertEnum(ctx.enumDeclaration());
|
|
|
|
}
|
|
|
|
return newClass;
|
|
|
|
}
|
|
|
|
|
|
|
|
private ClassOrInterface convertNormal(Java8Parser.NormalClassDeclarationContext ctx){
|
|
|
|
int modifiers = 0;
|
|
|
|
if(ctx.classModifier() != null){
|
|
|
|
for(Java8Parser.ClassModifierContext mod : ctx.classModifier()){
|
|
|
|
int newModifier = convert(mod);
|
|
|
|
modifiers += newModifier;
|
|
|
|
}
|
|
|
|
}
|
2017-03-22 16:10:51 +00:00
|
|
|
JavaClassName name = reg.getName(ctx.Identifier().getText());
|
2017-05-05 14:20:12 +00:00
|
|
|
GenericsRegistry generics = createGenerics(ctx.typeParameters(), name, "");
|
2017-04-18 19:06:04 +00:00
|
|
|
Token offset = ctx.getStart();
|
2017-03-29 15:28:29 +00:00
|
|
|
GenericDeclarationList genericClassParameters = TypeGenerator.convert(ctx.typeParameters(), name, "",reg, generics);
|
2017-05-05 14:20:12 +00:00
|
|
|
List<Field> fielddecl = convertFields(ctx.classBody(), generics);
|
|
|
|
List<Method> methods = convertMethods(ctx.classBody(), name, generics);
|
2017-04-18 19:06:04 +00:00
|
|
|
List<Constructor> konstruktoren = new ArrayList<>();
|
|
|
|
for(int i = 0; i<methods.size();i++){
|
|
|
|
Method m = methods.get(i);
|
|
|
|
if(m instanceof Constructor){
|
|
|
|
methods.remove(i);
|
|
|
|
konstruktoren.add((Constructor) m);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(konstruktoren.size()<1){//Standardkonstruktor anfügen:
|
|
|
|
konstruktoren.add(
|
|
|
|
generateStandardConstructor(
|
|
|
|
ctx.Identifier().getText(),
|
|
|
|
genericClassParameters, offset)
|
|
|
|
);
|
|
|
|
}
|
2017-03-22 15:05:59 +00:00
|
|
|
|
2017-03-17 14:48:06 +00:00
|
|
|
RefType superClass ;
|
|
|
|
if(ctx.superclass() != null){
|
|
|
|
superClass = convert(ctx.superclass());
|
|
|
|
}else{
|
|
|
|
superClass = new ASTFactory(reg).createObjectClass().getType();
|
|
|
|
}
|
2017-03-15 15:17:07 +00:00
|
|
|
Boolean isInterface = false;
|
2017-05-05 14:20:12 +00:00
|
|
|
List<RefTypeOrTPHOrWildcardOrGeneric> implementedInterfaces = convert(ctx.superinterfaces(), generics);
|
|
|
|
return new ClassOrInterface(modifiers, name, fielddecl, methods, konstruktoren, genericClassParameters, superClass,
|
|
|
|
isInterface, implementedInterfaces, offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
private List<RefTypeOrTPHOrWildcardOrGeneric> convert(Java8Parser.SuperinterfacesContext ctx, GenericsRegistry generics) {
|
|
|
|
if(ctx == null)return new ArrayList<>();
|
|
|
|
return convert(ctx.interfaceTypeList(), generics);
|
|
|
|
}
|
|
|
|
|
|
|
|
private List<RefTypeOrTPHOrWildcardOrGeneric> convert(Java8Parser.InterfaceTypeListContext ctx, GenericsRegistry generics) {
|
|
|
|
List<RefTypeOrTPHOrWildcardOrGeneric> ret = new ArrayList<>();
|
|
|
|
for(Java8Parser.InterfaceTypeContext interfaceType : ctx.interfaceType()){
|
|
|
|
ret.add(TypeGenerator.convert(interfaceType.classType(), reg, generics));
|
|
|
|
}
|
|
|
|
return ret;
|
2017-04-18 19:06:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private Constructor generateStandardConstructor(String className, GenericDeclarationList classGenerics, Token offset){
|
|
|
|
RefType classType = ClassOrInterface.generateTypeOfClass(reg.getName(className), classGenerics, offset);
|
|
|
|
int modifiers = 0;
|
|
|
|
ParameterList params = new ParameterList(new ArrayList<>(), offset);
|
|
|
|
//TODO: Konstruktor muss Felder initialisieren:
|
|
|
|
Block block = new Block(new ArrayList<>(), offset);
|
|
|
|
return new Constructor(className, classType, modifiers, params, block, classGenerics, offset);
|
2017-03-15 15:17:07 +00:00
|
|
|
}
|
|
|
|
|
2017-03-17 14:48:06 +00:00
|
|
|
private RefType convert(Java8Parser.SuperclassContext superclass) {
|
|
|
|
throw new NotImplementedException();
|
|
|
|
}
|
|
|
|
|
2017-05-05 14:20:12 +00:00
|
|
|
private List<Method> convertMethods(Java8Parser.ClassBodyContext classBodyContext,
|
|
|
|
JavaClassName parentClass, GenericsRegistry generics) {
|
2017-03-15 15:17:07 +00:00
|
|
|
List<Method> ret = new ArrayList<>();
|
|
|
|
for(Java8Parser.ClassBodyDeclarationContext classMember : classBodyContext.classBodyDeclaration()){
|
|
|
|
if(classMember.classMemberDeclaration() != null){
|
|
|
|
Java8Parser.ClassMemberDeclarationContext classMemberDeclarationContext = classMember.classMemberDeclaration();
|
|
|
|
if(classMemberDeclarationContext.fieldDeclaration() != null){
|
|
|
|
//Do nothing!
|
|
|
|
}else if(classMemberDeclarationContext.methodDeclaration()!= null){
|
2017-05-05 14:20:12 +00:00
|
|
|
|
|
|
|
ret.add(this.convert(classMemberDeclarationContext.methodDeclaration(), parentClass, generics));
|
2017-03-15 15:17:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-05-05 14:20:12 +00:00
|
|
|
private List<Field> convertFields(Java8Parser.ClassBodyContext classBodyContext, GenericsRegistry generics) {
|
2017-03-15 15:17:07 +00:00
|
|
|
List<Field> ret = new ArrayList<>();
|
|
|
|
for(Java8Parser.ClassBodyDeclarationContext classMember : classBodyContext.classBodyDeclaration()){
|
|
|
|
if(classMember.classMemberDeclaration() != null){
|
|
|
|
Java8Parser.ClassMemberDeclarationContext classMemberDeclarationContext = classMember.classMemberDeclaration();
|
|
|
|
if(classMemberDeclarationContext.fieldDeclaration() != null){
|
2017-05-05 14:20:12 +00:00
|
|
|
ret.addAll(convert(classMember.classMemberDeclaration().fieldDeclaration(), generics));
|
2017-03-15 15:17:07 +00:00
|
|
|
}else if(classMemberDeclarationContext.methodDeclaration()!= null){
|
|
|
|
//Do nothing!
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
public static int convert(List<Java8Parser.MethodModifierContext> methodModifierContexts) {
|
|
|
|
int ret = 0;
|
|
|
|
for(Java8Parser.MethodModifierContext mod : methodModifierContexts){
|
|
|
|
if(mod.annotation() == null)convertModifier(mod.getText());
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-05-05 14:20:12 +00:00
|
|
|
public static int convertInterfaceModifier(List<Java8Parser.InterfaceMethodModifierContext> methodModifierContexts) {
|
|
|
|
int ret = 0;
|
|
|
|
for(Java8Parser.InterfaceMethodModifierContext mod : methodModifierContexts){
|
|
|
|
if(mod.annotation() == null)convertModifier(mod.getText());
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
private List<? extends Field> convert(Java8Parser.FieldDeclarationContext fieldDeclarationContext, GenericsRegistry generics) {
|
2017-03-15 15:17:07 +00:00
|
|
|
List<Field> ret = new ArrayList<>();
|
|
|
|
int modifiers = 0;
|
|
|
|
for(Java8Parser.FieldModifierContext fieldModifierContext : fieldDeclarationContext.fieldModifier()){
|
|
|
|
modifiers+=(convert(fieldModifierContext));
|
|
|
|
}
|
2017-03-22 15:16:38 +00:00
|
|
|
RefTypeOrTPHOrWildcardOrGeneric fieldType;
|
|
|
|
if(fieldDeclarationContext.unannType() != null){
|
|
|
|
fieldType = TypeGenerator.convert(fieldDeclarationContext.unannType(), reg, generics);
|
|
|
|
}else{
|
|
|
|
fieldType = TypePlaceholder.fresh(fieldDeclarationContext.getStart());
|
|
|
|
}
|
2017-03-15 15:17:07 +00:00
|
|
|
for(Java8Parser.VariableDeclaratorContext varCtx : fieldDeclarationContext.variableDeclaratorList().variableDeclarator()){
|
|
|
|
String fieldName = convert(varCtx.variableDeclaratorId());
|
|
|
|
if(varCtx.variableInitializer() != null){
|
|
|
|
initializeField(fieldDeclarationContext);
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
ret.add(new Field(fieldName,fieldType,modifiers,varCtx.getStart()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
public static String convert(Java8Parser.VariableDeclaratorIdContext variableDeclaratorIdContext) {
|
|
|
|
return variableDeclaratorIdContext.getText();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize a field by creating implicit constructor.
|
|
|
|
private void initializeField(Java8Parser.FieldDeclarationContext ctx){
|
|
|
|
//TODO
|
2017-04-19 13:26:37 +00:00
|
|
|
throw new NotImplementedException();
|
2017-03-15 15:17:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public static int convertModifier(String modifier){
|
|
|
|
HashMap<String, Integer> modifiers = new HashMap<>();
|
|
|
|
modifiers.put(Modifier.toString(Modifier.PUBLIC), Modifier.PUBLIC);
|
|
|
|
modifiers.put(Modifier.toString(Modifier.PRIVATE), Modifier.PRIVATE);
|
|
|
|
modifiers.put(Modifier.toString(Modifier.PROTECTED), Modifier.PROTECTED);
|
|
|
|
modifiers.put(Modifier.toString(Modifier.ABSTRACT), Modifier.ABSTRACT);
|
|
|
|
modifiers.put(Modifier.toString(Modifier.STATIC), Modifier.STATIC);
|
|
|
|
modifiers.put(Modifier.toString(Modifier.STRICT), Modifier.STRICT);
|
|
|
|
modifiers.put(Modifier.toString(Modifier.FINAL), Modifier.FINAL);
|
|
|
|
modifiers.put(Modifier.toString(Modifier.TRANSIENT), Modifier.TRANSIENT);
|
|
|
|
modifiers.put(Modifier.toString(Modifier.VOLATILE), Modifier.VOLATILE);
|
|
|
|
modifiers.put(Modifier.toString(Modifier.SYNCHRONIZED), Modifier.SYNCHRONIZED);
|
|
|
|
modifiers.put(Modifier.toString(Modifier.NATIVE), Modifier.NATIVE);
|
|
|
|
modifiers.put(Modifier.toString(Modifier.INTERFACE), Modifier.INTERFACE);
|
|
|
|
int ret = 0;
|
|
|
|
for(String m : modifiers.keySet()){
|
2017-05-05 14:20:12 +00:00
|
|
|
if(modifier.contains(m))ret+=modifiers.get(m);
|
2017-03-15 15:17:07 +00:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
private int convert(Java8Parser.ClassModifierContext ctx){
|
|
|
|
if(ctx.annotation() != null)return 0;
|
|
|
|
return convertModifier(ctx.getText());
|
|
|
|
}
|
|
|
|
|
|
|
|
private int convert(Java8Parser.FieldModifierContext ctx){
|
|
|
|
if(ctx.annotation() != null)return 0;
|
|
|
|
return convertModifier(ctx.getText());
|
|
|
|
}
|
2017-05-05 14:20:12 +00:00
|
|
|
|
|
|
|
private int convert(Java8Parser.InterfaceModifierContext ctx) {
|
|
|
|
if(ctx.annotation() != null)return 0;
|
|
|
|
return convertModifier(ctx.getText());
|
|
|
|
}
|
2017-03-15 15:17:07 +00:00
|
|
|
|
|
|
|
private ClassOrInterface convertEnum(Java8Parser.EnumDeclarationContext ctx){
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
private ClassOrInterface convertInterface(Java8Parser.InterfaceDeclarationContext ctx){
|
2017-05-05 14:20:12 +00:00
|
|
|
if(ctx.normalInterfaceDeclaration() != null){
|
|
|
|
return convertNormal(ctx.normalInterfaceDeclaration());
|
|
|
|
}else{
|
|
|
|
throw new NotImplementedException();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private ClassOrInterface convertNormal(Java8Parser.NormalInterfaceDeclarationContext ctx) {
|
|
|
|
int modifiers = 0;
|
|
|
|
if(ctx.interfaceModifier() != null){
|
|
|
|
for( Java8Parser.InterfaceModifierContext mod : ctx.interfaceModifier()){
|
|
|
|
int newModifier = convert(mod);
|
|
|
|
modifiers += newModifier;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
JavaClassName name = reg.getName(ctx.Identifier().getText());
|
|
|
|
|
|
|
|
GenericsRegistry generics = createGenerics(ctx.typeParameters(), name, "");
|
|
|
|
|
|
|
|
List<Field> fields = convertFields(ctx.interfaceBody());
|
|
|
|
List<Method> methods = convertMethods(ctx.interfaceBody(), name, generics);
|
|
|
|
|
|
|
|
GenericDeclarationList genericParams = TypeGenerator.convert(ctx.typeParameters(), name, "",reg, generics);
|
|
|
|
RefType superClass = new ASTFactory(reg).createObjectClass().getType();
|
|
|
|
|
|
|
|
List<RefTypeOrTPHOrWildcardOrGeneric> extendedInterfaces = convert(ctx.extendsInterfaces(), generics);
|
|
|
|
|
|
|
|
return new ClassOrInterface(modifiers, name, fields, methods, new ArrayList<>(),
|
|
|
|
genericParams, superClass, true, extendedInterfaces, ctx.getStart());
|
|
|
|
}
|
|
|
|
|
|
|
|
private GenericsRegistry createGenerics(Java8Parser.TypeParametersContext ctx, JavaClassName parentClass, String parentMethod) {
|
|
|
|
GenericsRegistry ret = new GenericsRegistry();
|
|
|
|
if(ctx == null || ctx.typeParameterList() == null)return ret;
|
|
|
|
for(Java8Parser.TypeParameterContext tp : ctx.typeParameterList().typeParameter()){
|
|
|
|
TypeGenerator.convert(tp, parentClass, parentMethod, reg, ret);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
private List<RefTypeOrTPHOrWildcardOrGeneric> convert(Java8Parser.ExtendsInterfacesContext extendsInterfacesContext, GenericsRegistry generics) {
|
|
|
|
if(extendsInterfacesContext == null)return new ArrayList<>();
|
|
|
|
return convert(extendsInterfacesContext.interfaceTypeList(), generics);
|
|
|
|
}
|
|
|
|
|
|
|
|
private List<Method> convertMethods(Java8Parser.InterfaceBodyContext interfaceBodyContext,
|
|
|
|
JavaClassName parentClass, GenericsRegistry generics) {
|
|
|
|
List<Method> ret = new ArrayList<>();
|
|
|
|
for(Java8Parser.InterfaceMemberDeclarationContext member : interfaceBodyContext.interfaceMemberDeclaration()){
|
|
|
|
if(member.interfaceMethodDeclaration() != null){
|
|
|
|
ret.add(this.convert(member.interfaceMethodDeclaration(), parentClass, generics));
|
|
|
|
//new Method(name, type, modifier, params, null, genericDecls, member.interfaceMethodDeclaration().getStart());
|
|
|
|
}else{
|
|
|
|
throw new NotImplementedException();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
2017-03-15 15:17:07 +00:00
|
|
|
}
|
|
|
|
|
2017-05-05 14:20:12 +00:00
|
|
|
private List<Field> convertFields(Java8Parser.InterfaceBodyContext interfaceBodyContext) {
|
|
|
|
List<Field> ret = new ArrayList<>();
|
|
|
|
for(Java8Parser.InterfaceMemberDeclarationContext member : interfaceBodyContext.interfaceMemberDeclaration()){
|
|
|
|
if(member.constantDeclaration() != null){
|
|
|
|
//TODO: Erstelle hier ein Feld!
|
|
|
|
throw new NotImplementedException();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-03-15 15:17:07 +00:00
|
|
|
}
|