Compare commits
3 Commits
Author | SHA1 | Date | |
---|---|---|---|
2c240edb03 | |||
328bb4151f | |||
502307f7d8 |
.classpath
.idea/libraries
classes
doc
src
JavaCompilerCore1.iml
de
dhbwstuttgart
core
parser
ClassNotFoundException.javaJavaTXParser.javaPackageCrawler.javaRunTXParser.java
SyntaxTreeGenerator
AssignToLocal.javaStatementGenerator.javaSyntacticSugar.javaSyntaxTreeGenerator.javaTypeGenerator.java
antlr
syntaxtree
ASTVisitor.javaAbstractASTWalker.javaClassOrInterface.javaConstructor.javaField.javaFormalParameter.javaGTVDeclarationContext.javaGeneric.javaGenericDeclarationList.javaGenericTypeVar.javaMethod.javaParameterList.javaSourceFile.javaStatementVisitor.javaSyntaxTreeNode.java
factory
operator
AddOp.javaAndOp.javaDivideOp.javaEqualOp.javaGreaterEquOp.javaGreaterOp.javaLessEquOp.javaLessOp.javaLogOp.javaMinusOp.javaModuloOp.javaMulOp.javaNotEqualOp.javaOperator.javaOrOp.javaPlusOp.javaRelOp.javaTimesOp.java
statement
ArgumentList.javaAssertStmt.javaAssign.javaAssignLeftSide.javaAssignToField.javaBinary.javaBreakStmt.javaCatchesStatement.javaContinueStmt.javaDoStmt.javaExpression.javaIfStmt.javaInstVar.javaLambdaExpression.javaLambdaParameter.javaLocalVar.javaNewClass.javaPostDecExpr.javaPostIncExpr.javaPreDecExpr.javaPreIncExpr.javaSuperCall.javaSwitchStmt.javaThis.javaTypableStatement.javaWhileStmt.java
type
ExtendsWildcardType.javaFunN.javaGenericRefType.javaRefType.javaRefTypeOrTPHOrWildcardOrGeneric.javaSuperWildcardType.javaTypePlaceholder.javaWildcardType.java
visual
typecheck
typedeployment
typeinference
test
astfactory
javFiles
parser
AssertTest.javBreakTest.javFeatherWeightJavaTest.javaFieldTest.javaIfTest.javPrePostOperationTest.javRunParserTest.javaSwitchTest.javTryCatchTest.javWhileTest.jav
test.imltypeinference
tools
12
.classpath
12
.classpath
@ -4,18 +4,8 @@
|
||||
<classpathentry kind="src" path="test"/>
|
||||
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
|
||||
<classpathentry kind="lib" path="lib/bcel-6.1-SNAPSHOT.jar" sourcepath="lib/bcel-6.1-SNAPSHOT-sources.jar"/>
|
||||
<classpathentry kind="lib" path="lib/guava-10.0.1.jar"/>
|
||||
<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
|
||||
<classpathentry kind="lib" path="lib/antlr-complete.jar"/>
|
||||
<classpathentry kind="lib" path="lib/annotations-2.0.1.jar"/>
|
||||
<classpathentry kind="lib" path="lib/bcel-6.1-SNAPSHOT-sources.jar"/>
|
||||
<classpathentry kind="lib" path="lib/cloning.jar"/>
|
||||
<classpathentry kind="lib" path="lib/commons-bcel6-6.0-SNAPSHOT.jar"/>
|
||||
<classpathentry kind="lib" path="lib/javassist-3.19.0-GA.jar"/>
|
||||
<classpathentry kind="lib" path="lib/junit-4.0.jar"/>
|
||||
<classpathentry kind="lib" path="lib/log4j-1.2.12.jar"/>
|
||||
<classpathentry kind="lib" path="lib/reflections-0.9.10-javadoc.jar"/>
|
||||
<classpathentry kind="lib" path="lib/reflections-0.9.10-sources.jar"/>
|
||||
<classpathentry kind="lib" path="lib/reflections-0.9.10.jar" sourcepath="/reflections/src"/>
|
||||
<classpathentry kind="lib" path="lib/guava-22.0.jar" sourcepath="lib/guava-22.0-sources.jar"/>
|
||||
<classpathentry kind="output" path="bin"/>
|
||||
</classpath>
|
||||
|
22
.idea/libraries/lib.xml
generated
22
.idea/libraries/lib.xml
generated
@ -1,22 +0,0 @@
|
||||
<component name="libraryTable">
|
||||
<library name="lib">
|
||||
<CLASSES>
|
||||
<root url="jar://$PROJECT_DIR$/lib/log4j-1.2.12.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/guava-10.0.1.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/bcel-6.1-SNAPSHOT.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/bcel-6.1-SNAPSHOT-sources.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/annotations-2.0.1.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/guava-15.0.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/junit-4.0.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/commons-bcel6-6.0-SNAPSHOT.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/reflections-0.9.10-javadoc.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/reflections-0.9.10.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/cloning.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/javassist-3.19.0-GA.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/reflections-0.9.10-sources.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/antlr-complete.jar!/" />
|
||||
</CLASSES>
|
||||
<JAVADOC />
|
||||
<SOURCES />
|
||||
</library>
|
||||
</component>
|
@ -1,9 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<module type="WEB_MODULE" version="4">
|
||||
<component name="NewModuleRootManager" inherit-compiler-output="true">
|
||||
<exclude-output />
|
||||
<content url="file://$MODULE_DIR$" />
|
||||
<orderEntry type="inheritedJdk" />
|
||||
<orderEntry type="sourceFolder" forTests="false" />
|
||||
</component>
|
||||
</module>
|
@ -100,7 +100,7 @@ var activeTableTab = "activeTableTab";
|
||||
<li>java.lang.Object</li>
|
||||
<li>
|
||||
<ul class="inheritance">
|
||||
<li>de.dhbwstuttgart.typeinference.result.ResultSet</li>
|
||||
<li>de.dhbwstuttgart.typeinference.ResultSet</li>
|
||||
</ul>
|
||||
</li>
|
||||
</ul>
|
||||
|
@ -3,7 +3,7 @@
|
||||
<html lang="de">
|
||||
<head>
|
||||
<!-- Generated by javadoc (1.8.0_05) on Tue May 12 19:56:24 CEST 2015 -->
|
||||
<title>Uses of Class de.dhbwstuttgart.typeinference.result.ResultSet</title>
|
||||
<title>Uses of Class de.dhbwstuttgart.typeinference.ResultSet</title>
|
||||
<meta name="date" content="2015-05-12">
|
||||
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
|
||||
<script type="text/javascript" src="../../../../script.js"></script>
|
||||
@ -70,7 +70,7 @@
|
||||
</a></div>
|
||||
<!-- ========= END OF TOP NAVBAR ========= -->
|
||||
<div class="header">
|
||||
<h2 title="Uses of Class de.dhbwstuttgart.typeinference.result.ResultSet" class="title">Uses of Class<br>de.dhbwstuttgart.typeinference.ResultSet</h2>
|
||||
<h2 title="Uses of Class de.dhbwstuttgart.typeinference.ResultSet" class="title">Uses of Class<br>de.dhbwstuttgart.typeinference.ResultSet</h2>
|
||||
</div>
|
||||
<div class="classUseContainer">
|
||||
<ul class="blockList">
|
||||
|
Binary file not shown.
@ -1,9 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<module type="WEB_MODULE" version="4">
|
||||
<component name="NewModuleRootManager" inherit-compiler-output="true">
|
||||
<exclude-output />
|
||||
<content url="file://$MODULE_DIR$" />
|
||||
<orderEntry type="inheritedJdk" />
|
||||
<orderEntry type="sourceFolder" forTests="false" />
|
||||
</component>
|
||||
</module>
|
@ -1,11 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<module type="JAVA_MODULE" version="4">
|
||||
<component name="NewModuleRootManager" inherit-compiler-output="true">
|
||||
<exclude-output />
|
||||
<content url="file://$MODULE_DIR$">
|
||||
<sourceFolder url="file://$MODULE_DIR$" isTestSource="false" />
|
||||
</content>
|
||||
<orderEntry type="inheritedJdk" />
|
||||
<orderEntry type="sourceFolder" forTests="false" />
|
||||
</component>
|
||||
</module>
|
@ -1,18 +1,8 @@
|
||||
package de.dhbwstuttgart.core;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
public class ConsoleInterface {
|
||||
private static final String directory = System.getProperty("user.dir");
|
||||
|
||||
public static void main(String[] args) throws IOException, ClassNotFoundException {
|
||||
|
||||
JavaTXCompiler compiler = new JavaTXCompiler();
|
||||
for(String arg : Arrays.asList(args)){
|
||||
compiler.parse(new File(arg));
|
||||
}
|
||||
compiler.typeInference();
|
||||
}
|
||||
}
|
||||
|
@ -1,35 +1,53 @@
|
||||
package de.dhbwstuttgart.core;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.DebugException;
|
||||
import de.dhbwstuttgart.parser.ClassNotFoundException;
|
||||
import de.dhbwstuttgart.parser.JavaTXParser;
|
||||
import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
|
||||
import de.dhbwstuttgart.syntaxtree.SourceFile;
|
||||
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
|
||||
import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
|
||||
import de.dhbwstuttgart.typedeployment.TypeInsertPoint;
|
||||
import de.dhbwstuttgart.typeinference.ResultSet;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Constraint;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Pair;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSet;
|
||||
import de.dhbwstuttgart.typeinference.typeAlgo.TYPE;
|
||||
import de.dhbwstuttgart.typeinference.unify.TypeUnify;
|
||||
import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.util.*;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class JavaTXCompiler {
|
||||
|
||||
protected List<SourceFile> sourceFiles = new ArrayList<>();
|
||||
private List<SourceFile> sourceFiles = new ArrayList<>();
|
||||
|
||||
public List<ResultSet> typeInference(){
|
||||
public List<TypeInsertPoint> getTypeInserts(File forFile){
|
||||
ResultSet result = typeInference();
|
||||
for(SourceFile sf : sourceFiles){
|
||||
if(sf.getFile().equals(forFile)){
|
||||
return TypeInsertFactory.createTypeInsertPoints(sf, result);
|
||||
}
|
||||
}
|
||||
throw new DebugException("Die Datei "+forFile+" wurde nicht geparst");
|
||||
}
|
||||
|
||||
public ResultSet typeInference(){
|
||||
ConstraintSet<Pair> cons = new ConstraintSet<>();
|
||||
List<ClassOrInterface> allClasses = new ArrayList<>();
|
||||
for(SourceFile sf : sourceFiles){
|
||||
allClasses.addAll(sf.getClasses());
|
||||
}
|
||||
FiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses);
|
||||
final ConstraintSet<Pair> cons = new TYPE(sourceFiles).getConstraints();
|
||||
for(SourceFile sf : sourceFiles){
|
||||
cons.addAll(sf.getConstraints(sf.getTypeInferenceInformation(sourceFiles)));
|
||||
}
|
||||
ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(cons);
|
||||
|
||||
TypeUnify unify = new TypeUnify();
|
||||
@ -45,9 +63,8 @@ public class JavaTXCompiler {
|
||||
System.out.println("RESULT: " + result);
|
||||
results.addAll(result);
|
||||
}
|
||||
return results.stream().map((unifyPairs ->
|
||||
new ResultSet(UnifyTypeFactory.convert(unifyPairs, generateTPHMap(cons))))).collect(Collectors.toList());
|
||||
}
|
||||
return new ResultSet(UnifyTypeFactory.convert(results, generateTPHMap(cons)));
|
||||
}
|
||||
|
||||
private Map<String, TypePlaceholder> generateTPHMap(ConstraintSet<Pair> constraints){
|
||||
HashMap<String, TypePlaceholder> ret = new HashMap<>();
|
||||
@ -63,16 +80,8 @@ public class JavaTXCompiler {
|
||||
return ret;
|
||||
}
|
||||
|
||||
public SourceFile parse(File sourceFile) throws IOException, java.lang.ClassNotFoundException {
|
||||
SourceFile ret = new JavaTXParser().parse(sourceFile);
|
||||
sourceFiles.add(ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
public SourceFile parse(String source) throws IOException, java.lang.ClassNotFoundException {
|
||||
SourceFile ret = new JavaTXParser().parse(source);
|
||||
sourceFiles.add(ret);
|
||||
return ret;
|
||||
public void parse(File sourceFile) throws IOException, ClassNotFoundException {
|
||||
sourceFiles.add(new JavaTXParser().parse(sourceFile));
|
||||
}
|
||||
|
||||
}
|
||||
|
4
src/de/dhbwstuttgart/parser/ClassNotFoundException.java
Normal file
4
src/de/dhbwstuttgart/parser/ClassNotFoundException.java
Normal file
@ -0,0 +1,4 @@
|
||||
package de.dhbwstuttgart.parser;
|
||||
public class ClassNotFoundException extends Exception{
|
||||
|
||||
}
|
@ -9,30 +9,31 @@ import org.antlr.v4.runtime.ANTLRInputStream;
|
||||
import org.antlr.v4.runtime.CommonTokenStream;
|
||||
|
||||
import java.io.*;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class JavaTXParser {
|
||||
public SourceFile parse(InputStream source) throws IOException, java.lang.ClassNotFoundException {
|
||||
InputStream stream = source;//new FileInputStream(sourceFile);
|
||||
public SourceFile parse(File sourceFile) throws IOException, ClassNotFoundException {
|
||||
InputStream stream = new FileInputStream(sourceFile);
|
||||
ANTLRInputStream input = new ANTLRInputStream(stream);
|
||||
Java8Lexer lexer = new Java8Lexer(input);
|
||||
CommonTokenStream tokens = new CommonTokenStream(lexer);
|
||||
Java8Parser parser = new Java8Parser(tokens);
|
||||
Java8Parser.CompilationUnitContext tree = parser.compilationUnit();
|
||||
|
||||
JavaClassRegistry reg = new JavaClassRegistry(new ArrayList<>());
|
||||
reg.addPackage("java.lang");
|
||||
SyntaxTreeGenerator generator = new SyntaxTreeGenerator(reg);
|
||||
return generator.convert(tree);
|
||||
|
||||
SyntaxTreeGenerator generator = new SyntaxTreeGenerator(new JavaClassRegistry(generateJavaLangNames()));
|
||||
return generator.convert(tree, sourceFile);
|
||||
}
|
||||
|
||||
public SourceFile parse(File file) throws IOException, java.lang.ClassNotFoundException {
|
||||
return this.parse(new FileInputStream(file));
|
||||
}
|
||||
private List<String> generateJavaLangNames() throws IOException, ClassNotFoundException {
|
||||
List<String> ret = new ArrayList<>();
|
||||
|
||||
public SourceFile parse(String fileContent) throws IOException, java.lang.ClassNotFoundException {
|
||||
return this.parse(new ByteArrayInputStream(fileContent.getBytes(StandardCharsets.UTF_8)));
|
||||
for(Class cl : PackageCrawler.getClassesInPackage("java.lang")){
|
||||
ret.add(cl.getName());
|
||||
}
|
||||
//TODO: Wieso muss man das händisch anhängen?
|
||||
ret.add("java.lang.Object");
|
||||
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
48
src/de/dhbwstuttgart/parser/PackageCrawler.java
Normal file
48
src/de/dhbwstuttgart/parser/PackageCrawler.java
Normal file
@ -0,0 +1,48 @@
|
||||
package de.dhbwstuttgart.parser;
|
||||
|
||||
import de.dhbwstuttgart.typecheck.JavaClassName;
|
||||
import org.reflections.Reflections;
|
||||
import org.reflections.scanners.ResourcesScanner;
|
||||
import org.reflections.scanners.SubTypesScanner;
|
||||
import org.reflections.util.ClasspathHelper;
|
||||
import org.reflections.util.ConfigurationBuilder;
|
||||
import org.reflections.util.FilterBuilder;
|
||||
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Set;
|
||||
import java.lang.InterruptedException;
|
||||
/**
|
||||
* Hilft beim Durchsuchen von Packages
|
||||
* Benutzt die Reflections-Library (https://github.com/ronmamo/reflections)
|
||||
* Hilfe dazu: http://stackoverflow.com/a/9571146
|
||||
*/
|
||||
public class PackageCrawler {
|
||||
|
||||
public static Set<Class<?>> getClassesInPackage(String packageName){
|
||||
List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>();
|
||||
classLoadersList.add(Thread.currentThread().getContextClassLoader());
|
||||
classLoadersList.add(ClasspathHelper.staticClassLoader());
|
||||
classLoadersList.add(Thread.currentThread().getContextClassLoader().getParent());
|
||||
|
||||
Reflections reflections = new Reflections(new ConfigurationBuilder()
|
||||
.setScanners(new SubTypesScanner(false /* don't exclude Object.class */), new ResourcesScanner())
|
||||
.setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0])))
|
||||
.filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(packageName))));
|
||||
|
||||
Set<Class<?>> classes = reflections.getSubTypesOf(Object.class);
|
||||
|
||||
return classes;
|
||||
}
|
||||
|
||||
// Returns a list of JavaClassNames.
|
||||
public static List<JavaClassName> getClassNames(String packageName){
|
||||
List<JavaClassName> nameList = new ArrayList();
|
||||
Set<Class<?>> classes = getClassesInPackage(packageName);
|
||||
for(Class c : classes){
|
||||
nameList.add(new JavaClassName(c.getName()));
|
||||
}
|
||||
return nameList;
|
||||
}
|
||||
}
|
57
src/de/dhbwstuttgart/parser/RunTXParser.java
Normal file
57
src/de/dhbwstuttgart/parser/RunTXParser.java
Normal file
@ -0,0 +1,57 @@
|
||||
package de.dhbwstuttgart.parser;
|
||||
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.SyntaxTreeGenerator;
|
||||
import de.dhbwstuttgart.parser.antlr.Java8Lexer;
|
||||
import de.dhbwstuttgart.parser.antlr.Java8Parser;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassName;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassRegistry;
|
||||
import org.antlr.v4.runtime.ANTLRInputStream;
|
||||
import org.antlr.v4.runtime.CommonTokenStream;
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Scanner;
|
||||
import java.io.File;
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.InputStream;
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
public class RunTXParser{
|
||||
public static void main(String[] args){
|
||||
try{
|
||||
JavaTXParser parser = new JavaTXParser();
|
||||
SourceFile f = parser.parse(new File(args[0]));
|
||||
String pkgName = f.getPkgName();
|
||||
System.out.println("package: " + pkgName);
|
||||
System.out.println("Imports:");
|
||||
for(JavaClassName c : f.getImports()){
|
||||
System.out.println(c.toString());
|
||||
}
|
||||
System.out.println("classes:");
|
||||
for(ClassOrInterface c : f.getClasses()){
|
||||
int mod = c.getModifiers();
|
||||
System.out.println(Modifier.toString(mod));
|
||||
System.out.println(c.getClassName().toString());
|
||||
System.out.println("{");
|
||||
for(Field field : c.getFieldDecl()){
|
||||
System.out.println(field.getName());
|
||||
}
|
||||
System.out.println("}");
|
||||
}
|
||||
}
|
||||
catch(java.util.NoSuchElementException e){
|
||||
System.out.println("Error: Source seems to be empty.");
|
||||
}
|
||||
catch(ClassNotFoundException e){
|
||||
System.out.println("Class not found.");
|
||||
}
|
||||
catch(FileNotFoundException e){
|
||||
System.out.println("File not found.");
|
||||
}
|
||||
catch(IOException e){
|
||||
System.out.println("An exception occured which is on our TODO list.");
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
@ -1,20 +0,0 @@
|
||||
package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.AssignLeftSide;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Expression;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.LocalVar;
|
||||
|
||||
public class AssignToLocal extends AssignLeftSide {
|
||||
public final LocalVar localVar;
|
||||
|
||||
public AssignToLocal(LocalVar leftSide) {
|
||||
super(leftSide.getType(), leftSide.getOffset());
|
||||
localVar = leftSide;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
@ -1,32 +1,33 @@
|
||||
package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
|
||||
|
||||
import com.sun.javafx.fxml.expression.UnaryExpression;
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.parser.NullToken;
|
||||
import de.dhbwstuttgart.parser.antlr.Java8Parser;
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
import de.dhbwstuttgart.syntaxtree.operator.AndOp;
|
||||
import de.dhbwstuttgart.syntaxtree.operator.OrOp;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.*;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.syntaxtree.type.Void;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassName;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassRegistry;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
import org.antlr.v4.runtime.tree.TerminalNode;
|
||||
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.util.*;
|
||||
|
||||
public class StatementGenerator {
|
||||
|
||||
private JavaClassRegistry reg;
|
||||
private Map<String, RefTypeOrTPHOrWildcardOrGeneric> localVars;
|
||||
private Map<String, RefTypeOrTPHOrWildcardOrGeneric> localVars = new HashMap<>();
|
||||
private GenericsRegistry generics;
|
||||
|
||||
public StatementGenerator(JavaClassRegistry reg, GenericsRegistry generics, Map<String, RefTypeOrTPHOrWildcardOrGeneric> localVars){
|
||||
public StatementGenerator(JavaClassRegistry reg, GenericsRegistry generics){
|
||||
this.reg = reg;
|
||||
this.generics = generics;
|
||||
this.localVars = localVars;
|
||||
}
|
||||
|
||||
public ParameterList convert(Java8Parser.FormalParameterListContext formalParameterListContext) {
|
||||
@ -267,78 +268,64 @@ public class StatementGenerator {
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
//TODO Felix_K
|
||||
|
||||
private Statement convert(Java8Parser.PreIncrementExpressionContext stmt) {
|
||||
return new PreIncExpr(convert(stmt.unaryExpression()),stmt.getStart());
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
//TODO Felix_K
|
||||
|
||||
private Statement convert(Java8Parser.PreDecrementExpressionContext stmt) {
|
||||
return new PreDecExpr(convert(stmt.unaryExpression()),stmt.getStart());
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
//TODO Felix_K
|
||||
|
||||
private Statement convert(Java8Parser.PostIncrementExpressionContext stmt) {
|
||||
return new PostIncExpr(convert(stmt.postfixExpression()));
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
//TODO Felix_K
|
||||
|
||||
private Statement convert(Java8Parser.PostDecrementExpressionContext stmt) {
|
||||
return new PostDecExpr(convert(stmt.postfixExpression()));
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.AssignmentContext stmt) {
|
||||
AssignLeftSide leftHandSide = convert(stmt.leftHandSide());
|
||||
Expression leftHandSide = convert(stmt.leftHandSide());
|
||||
return new Assign(leftHandSide, convert(stmt.expression()), stmt.getStart());
|
||||
}
|
||||
|
||||
private AssignLeftSide convert(Java8Parser.LeftHandSideContext leftHandSide) {
|
||||
Expression leftSide = generateLocalOrFieldVarOrClassName(leftHandSide.getText(), leftHandSide.getStart());
|
||||
if(leftSide instanceof FieldVar)return new AssignToField((FieldVar) leftSide);
|
||||
else if (leftSide instanceof LocalVar)return new AssignToLocal((LocalVar) leftSide);
|
||||
else throw new NotImplementedException();
|
||||
private Expression convert(Java8Parser.LeftHandSideContext leftHandSide) {
|
||||
return generateLocalOrFieldVarOrClassName(leftHandSide.getText(), leftHandSide.getStart());
|
||||
}
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.IfThenStatementContext stmt){
|
||||
Expression expr = convert(stmt.expression());
|
||||
Statement thenBlock = convert(stmt.statement());
|
||||
Statement elseBlock = new EmptyStmt(stmt.getStart());
|
||||
return new IfStmt(TypePlaceholder.fresh(stmt.getStart()),expr,thenBlock,elseBlock,stmt.getStart());
|
||||
}
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.IfThenElseStatementContext stmt){
|
||||
Expression expr = convert(stmt.expression());
|
||||
Statement thenBlock = convert(stmt.statementNoShortIf());
|
||||
Statement elseBlock = convert(stmt.statement());
|
||||
return new IfStmt(TypePlaceholder.fresh(stmt.getStart()),expr,thenBlock,elseBlock,stmt.getStart());
|
||||
}
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.IfThenElseStatementNoShortIfContext stmt){
|
||||
Expression expr = convert(stmt.expression());
|
||||
Statement thenBlock = convert(stmt.statementNoShortIf().get(0));
|
||||
Statement elseBlock = convert(stmt.statementNoShortIf().get(1));
|
||||
return new IfStmt(TypePlaceholder.fresh(stmt.getStart()),expr,thenBlock,elseBlock,stmt.getStart());
|
||||
}
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.AssertStatementContext stmt)
|
||||
{
|
||||
List<Expression> exprList= new ArrayList<Expression>();
|
||||
for (int i =0; i<stmt.expression().size();i++){
|
||||
exprList.add(convert(stmt.expression(i)));
|
||||
}
|
||||
return new AssertStmt(TypePlaceholder.fresh(stmt.getStart()),exprList,stmt.getStart());
|
||||
}
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.SwitchStatementContext stmt){
|
||||
Expression expr = convert(stmt.expression());
|
||||
List<Statement> statementList = new ArrayList<Statement>();
|
||||
statementList.add( convert(stmt.switchBlock()));
|
||||
statementList.add(new BreakStmt(TypePlaceholder.fresh(stmt.getStart()),"",stmt.getStart()));
|
||||
Block block = new Block(statementList, stmt.getStart());
|
||||
return new SwitchStmt(TypePlaceholder.fresh(stmt.getStart()),expr,block,stmt.getStart());
|
||||
|
||||
private Statement convert(Java8Parser.IfThenStatementContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.IfThenElseStatementContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.IfThenElseStatementNoShortIfContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.AssertStatementContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.SwitchStatementContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.SwitchBlockContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.SwitchBlockStatementGroupContext stmt){
|
||||
@ -347,21 +334,18 @@ public class StatementGenerator {
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.WhileStatementContext stmt){
|
||||
Expression expr = convert(stmt.expression());
|
||||
Statement block = convert(stmt.statement());
|
||||
return new WhileStmt(expr, block,stmt.getStart());
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
//TODO Felix_K
|
||||
|
||||
private Statement convert(Java8Parser.WhileStatementNoShortIfContext stmt){
|
||||
Expression expr = convert(stmt.expression());
|
||||
Statement block = convert(stmt.statementNoShortIf());
|
||||
return new WhileStmt(expr, block, stmt.getStart());
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
//TODO Felix_K
|
||||
|
||||
private Statement convert(Java8Parser.DoStatementContext stmt){
|
||||
Statement block = convert(stmt.statement());
|
||||
Expression expr = convert(stmt.expression());
|
||||
return new DoStmt(expr,block,stmt.getStart());
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.ForStatementContext stmt){
|
||||
@ -379,43 +363,15 @@ public class StatementGenerator {
|
||||
return convert(stmt.enhancedForStatementNoShortIf());
|
||||
}else throw new NotImplementedException();
|
||||
}
|
||||
//TODO Felix_K
|
||||
|
||||
private Statement convert(Java8Parser.BasicForStatementContext stmt){
|
||||
List<Statement> stateList = new ArrayList<>();
|
||||
List<Statement> whileList = new ArrayList<>();
|
||||
if (stmt.forInit().localVariableDeclaration()==null)
|
||||
{
|
||||
whileList.addAll(convert(stmt.forInit().localVariableDeclaration()));
|
||||
}
|
||||
else
|
||||
{
|
||||
whileList.add(convert(stmt.forInit().statementExpressionList()));
|
||||
}
|
||||
Expression expr = convert(stmt.expression());
|
||||
stateList.add(convert(stmt.statement()));
|
||||
stateList.add(convert(stmt.forUpdate()));
|
||||
Block forBlock = new Block(stateList,stmt.getStart());
|
||||
whileList.add(new WhileStmt(expr,forBlock,stmt.getStart()));
|
||||
return new Block(whileList,stmt.getStart());
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
//TODO Felix_K
|
||||
|
||||
private Statement convert(Java8Parser.BasicForStatementNoShortIfContext stmt){
|
||||
List<Statement> stateList = new ArrayList<>();
|
||||
List<Statement> whileList = new ArrayList<>();
|
||||
if (stmt.forInit().localVariableDeclaration()==null)
|
||||
{
|
||||
whileList.addAll(convert(stmt.forInit().localVariableDeclaration()));
|
||||
}
|
||||
else
|
||||
{
|
||||
whileList.add(convert(stmt.forInit().statementExpressionList()));
|
||||
}
|
||||
Expression expr = convert(stmt.expression());
|
||||
stateList.add(convert(stmt.statementNoShortIf()));
|
||||
stateList.add(convert(stmt.forUpdate()));
|
||||
Block forBlock = new Block(stateList,stmt.getStart());
|
||||
whileList.add(new WhileStmt(expr,forBlock,stmt.getStart()));
|
||||
return new Block(whileList,stmt.getStart());
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private List<Statement> convert(Java8Parser.ForInitContext stmt){
|
||||
@ -425,7 +381,7 @@ public class StatementGenerator {
|
||||
return convert(stmt.localVariableDeclaration());
|
||||
}else throw new NotImplementedException();
|
||||
}
|
||||
//TODO Felix_K
|
||||
|
||||
private List<Statement> convert(Java8Parser.LocalVariableDeclarationContext declaration) {
|
||||
List<Statement> ret = new ArrayList<>();
|
||||
if(declaration.variableModifier() != null && declaration.variableModifier().size() > 0){
|
||||
@ -438,13 +394,7 @@ public class StatementGenerator {
|
||||
}else{
|
||||
type = TypeGenerator.convert(declaration.unannTypeOrAuto().unannType(), reg, generics);
|
||||
}
|
||||
ret.addAll(generateLocalVariableAssignments(declaration.variableDeclaratorList().variableDeclarator(), type));
|
||||
return ret;
|
||||
}
|
||||
|
||||
private List<Statement> generateLocalVariableAssignments(List<Java8Parser.VariableDeclaratorContext> varDeclarators, RefTypeOrTPHOrWildcardOrGeneric type){
|
||||
List<Statement> ret = new ArrayList<>();
|
||||
for(Java8Parser.VariableDeclaratorContext varDecl : varDeclarators){
|
||||
for(Java8Parser.VariableDeclaratorContext varDecl : declaration.variableDeclaratorList().variableDeclarator()){
|
||||
TerminalNode name = varDecl.variableDeclaratorId().Identifier();
|
||||
|
||||
ret.add(new LocalVarDecl(name.getText(), type, name.getSymbol()));
|
||||
@ -456,27 +406,12 @@ public class StatementGenerator {
|
||||
}else{
|
||||
initValue = convert(varDecl.variableInitializer().expression());
|
||||
}
|
||||
ret.add(new Assign(new AssignToLocal(new LocalVar(name.getText(), type, name.getSymbol()))
|
||||
, initValue, name.getSymbol()));
|
||||
ret.add(new Assign(new LocalVar(name.getText(), type, name.getSymbol()), initValue, name.getSymbol()));
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
public Statement generateFieldAssignment(Java8Parser.VariableDeclaratorContext varDecl, RefTypeOrTPHOrWildcardOrGeneric type){
|
||||
TerminalNode name = varDecl.variableDeclaratorId().Identifier();
|
||||
Expression initValue;
|
||||
if(varDecl.variableInitializer().arrayInitializer() != null){
|
||||
throw new NotImplementedException();
|
||||
}else{
|
||||
initValue = convert(varDecl.variableInitializer().expression());
|
||||
}
|
||||
return (new Assign(new AssignToField(
|
||||
new FieldVar(new This(varDecl.getStart()), name.getText(),
|
||||
new Void(varDecl.getStart()), varDecl.getStart())),
|
||||
initValue, name.getSymbol()));
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.ForUpdateContext stmt){
|
||||
return convert(stmt.statementExpressionList());
|
||||
}
|
||||
@ -495,30 +430,20 @@ public class StatementGenerator {
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
//TODO Felix_K
|
||||
|
||||
private Statement convert(Java8Parser.BreakStatementContext stmt){
|
||||
if (stmt.Identifier()==null)
|
||||
{
|
||||
String indentifier = "";
|
||||
return new BreakStmt(TypePlaceholder.fresh(stmt.getStart()),indentifier,stmt.getStart());
|
||||
}
|
||||
return new BreakStmt(TypePlaceholder.fresh(stmt.getStart()),stmt.Identifier().getText(),stmt.getStart());
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
//TODO Felix_K
|
||||
|
||||
private Statement convert(Java8Parser.ContinueStatementContext stmt){
|
||||
if (stmt.Identifier()==null){
|
||||
String indentifier = "";
|
||||
return new ContinueStmt(TypePlaceholder.fresh(stmt.getStart()),indentifier, stmt.getStart());
|
||||
}
|
||||
return new BreakStmt(TypePlaceholder.fresh(stmt.getStart()),stmt.Identifier().getText(),stmt.getStart());
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.ReturnStatementContext stmt){
|
||||
if(stmt.expression() != null){
|
||||
return new Return( convert(stmt.expression()),stmt.getStart() );
|
||||
}else{
|
||||
return new ReturnVoid(stmt.getStart());
|
||||
}
|
||||
return new Return(convert(stmt.expression()),stmt.getStart());
|
||||
//throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.ThrowStatementContext stmt){
|
||||
@ -536,8 +461,7 @@ public class StatementGenerator {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.CatchesContext stmt)
|
||||
{
|
||||
private Statement convert(Java8Parser.CatchesContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
@ -580,7 +504,7 @@ public class StatementGenerator {
|
||||
return convert(expression.conditionalAndExpression());
|
||||
}else{
|
||||
return new Binary(convert(expression.conditionalOrExpression()),
|
||||
convert(expression.conditionalAndExpression()), Binary.Operator.OR);
|
||||
convert(expression.conditionalAndExpression()), new OrOp(null));
|
||||
}
|
||||
}
|
||||
|
||||
@ -589,7 +513,7 @@ public class StatementGenerator {
|
||||
return convert(expression.inclusiveOrExpression());
|
||||
}else{
|
||||
return new Binary(convert(expression.conditionalAndExpression()),
|
||||
convert(expression.inclusiveOrExpression()), Binary.Operator.AND);
|
||||
convert(expression.inclusiveOrExpression()), new AndOp(null));
|
||||
}
|
||||
}
|
||||
|
||||
@ -874,21 +798,14 @@ public class StatementGenerator {
|
||||
params = new ParameterList(new ArrayList<>(), expression.getStart());
|
||||
}
|
||||
|
||||
HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> lambdaLocals = new HashMap<>();
|
||||
lambdaLocals.putAll(localVars);
|
||||
for(FormalParameter param : params.getFormalparalist()){
|
||||
lambdaLocals.put(param.getName(), param.getType());
|
||||
}
|
||||
StatementGenerator lambdaGenerator = new StatementGenerator(reg, generics, lambdaLocals);
|
||||
|
||||
Block block;
|
||||
if(expression.lambdaBody().expression() != null){
|
||||
List<Statement> statements = new ArrayList<>();
|
||||
statements.add(new Return(lambdaGenerator.convert(expression.lambdaBody().expression()),
|
||||
statements.add(new Return(convert(expression.lambdaBody().expression()),
|
||||
expression.lambdaBody().expression().getStart()));
|
||||
block = new Block(statements, expression.lambdaBody().getStart());
|
||||
}else{
|
||||
block = lambdaGenerator.convert(expression.lambdaBody().block());
|
||||
block = convert(expression.lambdaBody().block());
|
||||
}
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> funNParams = new ArrayList<>();
|
||||
funNParams.add(TypePlaceholder.fresh(expression.getStart()));//ret-Type
|
||||
@ -896,7 +813,7 @@ public class StatementGenerator {
|
||||
funNParams.add(TypePlaceholder.fresh(expression.getStart())));
|
||||
RefTypeOrTPHOrWildcardOrGeneric lambdaType = TypePlaceholder.fresh(expression.getStart());
|
||||
//RefType lambdaType = new RefType(reg.getName("Fun"+params.getFormalparalist().size()),
|
||||
//funNParams, name.getStart());
|
||||
//funNParams, expression.getStart());
|
||||
return new LambdaExpression(lambdaType, params, block, expression.getStart());
|
||||
}
|
||||
}
|
||||
|
@ -12,11 +12,10 @@ public class SyntacticSugar {
|
||||
Statement lastStmt = statements.get(statements.size() - 1);
|
||||
if (lastStmt instanceof Return) return statements;
|
||||
if (lastStmt instanceof WhileStmt) {
|
||||
//TODO
|
||||
//if (hasReturn(((WhileStmt) lastStmt).loopBlock)) return statements;
|
||||
if (hasReturn(((WhileStmt) lastStmt).loop_block)) return statements;
|
||||
} else if (lastStmt instanceof IfStmt) {
|
||||
//if (hasReturn(((IfStmt) lastStmt).then_block)
|
||||
//&& hasReturn(((IfStmt) lastStmt).else_block)) return statements;
|
||||
if (hasReturn(((IfStmt) lastStmt).then_block)
|
||||
&& hasReturn(((IfStmt) lastStmt).else_block)) return statements;
|
||||
} else if (lastStmt instanceof ForStmt) {
|
||||
if (hasReturn(((ForStmt) lastStmt).body_Loop_block)) return statements;
|
||||
} else {
|
||||
|
@ -1,8 +1,8 @@
|
||||
package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import java.lang.ClassNotFoundException;
|
||||
import de.dhbwstuttgart.parser.NullToken;
|
||||
import de.dhbwstuttgart.parser.ClassNotFoundException;
|
||||
import de.dhbwstuttgart.parser.PackageCrawler;
|
||||
import de.dhbwstuttgart.parser.antlr.Java8Parser;
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
|
||||
@ -14,13 +14,11 @@ import de.dhbwstuttgart.typecheck.*;
|
||||
|
||||
import java.io.File;
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.sql.Ref;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
|
||||
//import jdk.internal.dynalink.support.TypeConverterFactory;
|
||||
import org.antlr.v4.runtime.CommonToken;
|
||||
import jdk.internal.dynalink.support.TypeConverterFactory;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
import org.antlr.v4.runtime.tree.TerminalNode;
|
||||
|
||||
@ -29,8 +27,6 @@ public class SyntaxTreeGenerator{
|
||||
private String pkgName = "";
|
||||
List<JavaClassName> imports = new ArrayList();
|
||||
|
||||
List<Statement> fieldInitializations = new ArrayList<>();
|
||||
|
||||
public SyntaxTreeGenerator(JavaClassRegistry reg){
|
||||
this.reg = reg;
|
||||
}
|
||||
@ -138,10 +134,16 @@ public class SyntaxTreeGenerator{
|
||||
|
||||
private JavaClassName convertSingleTypeImportDeclaration(Java8Parser.SingleTypeImportDeclarationContext ctx) throws ClassNotFoundException{
|
||||
String typeName = convertTypeName(ctx.typeName());
|
||||
Thread.currentThread().getContextClassLoader().loadClass(typeName);
|
||||
reg.add(typeName);
|
||||
JavaClassName ret = reg.getName(typeName);
|
||||
return ret;
|
||||
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{
|
||||
throw new ClassNotFoundException();
|
||||
}
|
||||
}
|
||||
|
||||
private JavaClassName convertTypeImportOnDemandDeclaration(Java8Parser.TypeImportOnDemandDeclarationContext ctx){
|
||||
@ -166,7 +168,7 @@ public class SyntaxTreeGenerator{
|
||||
return ret;
|
||||
}
|
||||
|
||||
public SourceFile convert(Java8Parser.CompilationUnitContext ctx) throws ClassNotFoundException{
|
||||
public SourceFile convert(Java8Parser.CompilationUnitContext ctx, File parsedFile) throws ClassNotFoundException{
|
||||
List<ClassOrInterface> classes = new ArrayList<>();
|
||||
this.getNames(ctx);
|
||||
this.setImports(ctx);
|
||||
@ -180,39 +182,37 @@ public class SyntaxTreeGenerator{
|
||||
}
|
||||
classes.add(newClass);
|
||||
}
|
||||
return new SourceFile(this.pkgName, classes, this.imports);
|
||||
return new SourceFile(parsedFile, this.pkgName, classes, this.imports);
|
||||
}
|
||||
|
||||
public Method convert(Java8Parser.MethodDeclarationContext methodDeclarationContext, JavaClassName parentClass, RefType superClass, GenericsRegistry generics) {
|
||||
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, superClass, localGenerics);
|
||||
return convert(modifiers, header, methodDeclarationContext.methodBody(),parentClass, localGenerics);
|
||||
}
|
||||
|
||||
public Method convert(Java8Parser.InterfaceMethodDeclarationContext ctx, JavaClassName parentClass, RefType superClass, GenericsRegistry generics) {
|
||||
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, superClass, localGenerics);
|
||||
return convert(modifiers, header, ctx.methodBody(),parentClass, localGenerics);
|
||||
}
|
||||
|
||||
private Method convert(int modifiers, Java8Parser.MethodHeaderContext header, Java8Parser.MethodBodyContext body,
|
||||
JavaClassName parentClass, RefType superClass, GenericsRegistry localGenerics) {
|
||||
JavaClassName parentClass, GenericsRegistry localGenerics) {
|
||||
|
||||
StatementGenerator stmtGen = new StatementGenerator(reg, localGenerics, new HashMap<>());
|
||||
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);
|
||||
}else{
|
||||
gtvDeclarations = new GenericDeclarationList(new ArrayList<>(), header.getStart());
|
||||
}
|
||||
RefTypeOrTPHOrWildcardOrGeneric retType;
|
||||
if(header.result() != null){
|
||||
@ -233,7 +233,7 @@ public class SyntaxTreeGenerator{
|
||||
block = stmtGen.convert(body.block());
|
||||
}
|
||||
if(parentClass.equals(new JavaClassName(name))){
|
||||
return new Constructor(name, retType, modifiers, parameterList, block, gtvDeclarations, header.getStart(), fieldInitializations, superClass);
|
||||
return new Constructor(name, retType, modifiers, parameterList, block, gtvDeclarations, header.getStart());
|
||||
}else{
|
||||
return new Method(name, retType, modifiers, parameterList,block, gtvDeclarations, header.getStart());
|
||||
}
|
||||
@ -261,20 +261,9 @@ public class SyntaxTreeGenerator{
|
||||
JavaClassName name = reg.getName(ctx.Identifier().getText());
|
||||
GenericsRegistry generics = createGenerics(ctx.typeParameters(), name, "");
|
||||
Token offset = ctx.getStart();
|
||||
GenericDeclarationList genericClassParameters;
|
||||
if(ctx.typeParameters() == null){
|
||||
genericClassParameters = createEmptyGenericDeclarationList(ctx.Identifier());
|
||||
}else{
|
||||
genericClassParameters = TypeGenerator.convert(ctx.typeParameters(), name, "",reg, generics);
|
||||
}
|
||||
RefType superClass ;
|
||||
if(ctx.superclass() != null){
|
||||
superClass = convert(ctx.superclass());
|
||||
}else{
|
||||
superClass = ASTFactory.createObjectClass().getType();
|
||||
}
|
||||
GenericDeclarationList genericClassParameters = TypeGenerator.convert(ctx.typeParameters(), name, "",reg, generics);
|
||||
List<Field> fielddecl = convertFields(ctx.classBody(), generics);
|
||||
List<Method> methods = convertMethods(ctx.classBody(), name, superClass, generics);
|
||||
List<Method> methods = convertMethods(ctx.classBody(), name, generics);
|
||||
List<Constructor> konstruktoren = new ArrayList<>();
|
||||
for(int i = 0; i<methods.size();i++){
|
||||
Method m = methods.get(i);
|
||||
@ -286,11 +275,18 @@ public class SyntaxTreeGenerator{
|
||||
if(konstruktoren.size()<1){//Standardkonstruktor anfügen:
|
||||
konstruktoren.add(
|
||||
generateStandardConstructor(
|
||||
ctx.Identifier().getText(), name, superClass,
|
||||
ctx.Identifier().getText(),
|
||||
genericClassParameters, offset)
|
||||
);
|
||||
}
|
||||
|
||||
RefType superClass = null ;
|
||||
/*
|
||||
if(ctx.superclass() != null){
|
||||
superClass = convert(ctx.superclass());
|
||||
}else{
|
||||
superClass = new ASTFactory(reg).createObjectClass().getType();
|
||||
}*/
|
||||
Boolean isInterface = false;
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> implementedInterfaces = convert(ctx.superinterfaces(), generics);
|
||||
return new ClassOrInterface(modifiers, name, fielddecl, methods, konstruktoren, genericClassParameters, superClass,
|
||||
@ -310,12 +306,13 @@ public class SyntaxTreeGenerator{
|
||||
return ret;
|
||||
}
|
||||
|
||||
private Constructor generateStandardConstructor(String className, JavaClassName parentClass, RefType superClass, GenericDeclarationList classGenerics, Token offset){
|
||||
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, fieldInitializations, superClass);
|
||||
return new Constructor(className, classType, modifiers, params, block, classGenerics, offset);
|
||||
}
|
||||
|
||||
private RefType convert(Java8Parser.SuperclassContext superclass) {
|
||||
@ -323,7 +320,7 @@ public class SyntaxTreeGenerator{
|
||||
}
|
||||
|
||||
private List<Method> convertMethods(Java8Parser.ClassBodyContext classBodyContext,
|
||||
JavaClassName parentClass, RefType superClass, GenericsRegistry generics) {
|
||||
JavaClassName parentClass, GenericsRegistry generics) {
|
||||
List<Method> ret = new ArrayList<>();
|
||||
for(Java8Parser.ClassBodyDeclarationContext classMember : classBodyContext.classBodyDeclaration()){
|
||||
if(classMember.classMemberDeclaration() != null){
|
||||
@ -332,7 +329,7 @@ public class SyntaxTreeGenerator{
|
||||
//Do nothing!
|
||||
}else if(classMemberDeclarationContext.methodDeclaration()!= null){
|
||||
|
||||
ret.add(this.convert(classMemberDeclarationContext.methodDeclaration(), parentClass, superClass, generics));
|
||||
ret.add(this.convert(classMemberDeclarationContext.methodDeclaration(), parentClass, generics));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -385,7 +382,7 @@ public class SyntaxTreeGenerator{
|
||||
for(Java8Parser.VariableDeclaratorContext varCtx : fieldDeclarationContext.variableDeclaratorList().variableDeclarator()){
|
||||
String fieldName = convert(varCtx.variableDeclaratorId());
|
||||
if(varCtx.variableInitializer() != null){
|
||||
initializeField(varCtx, fieldType, generics);
|
||||
initializeField(fieldDeclarationContext);
|
||||
}
|
||||
else{
|
||||
ret.add(new Field(fieldName,fieldType,modifiers,varCtx.getStart()));
|
||||
@ -399,9 +396,9 @@ public class SyntaxTreeGenerator{
|
||||
}
|
||||
|
||||
// Initialize a field by creating implicit constructor.
|
||||
private void initializeField(Java8Parser.VariableDeclaratorContext ctx, RefTypeOrTPHOrWildcardOrGeneric typeOfField, GenericsRegistry generics){
|
||||
StatementGenerator statementGenerator = new StatementGenerator(reg, generics, new HashMap<>());
|
||||
fieldInitializations.add(statementGenerator.generateFieldAssignment(ctx, typeOfField));
|
||||
private void initializeField(Java8Parser.FieldDeclarationContext ctx){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public static int convertModifier(String modifier){
|
||||
@ -464,16 +461,11 @@ public class SyntaxTreeGenerator{
|
||||
|
||||
GenericsRegistry generics = createGenerics(ctx.typeParameters(), name, "");
|
||||
|
||||
GenericDeclarationList genericParams;
|
||||
if(ctx.typeParameters() != null){
|
||||
genericParams = TypeGenerator.convert(ctx.typeParameters(), name, "",reg, generics);
|
||||
}else{
|
||||
genericParams = createEmptyGenericDeclarationList(ctx.Identifier());
|
||||
}
|
||||
RefType superClass = ASTFactory.createObjectClass().getType();
|
||||
|
||||
List<Field> fields = convertFields(ctx.interfaceBody());
|
||||
List<Method> methods = convertMethods(ctx.interfaceBody(), name, superClass, generics);
|
||||
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);
|
||||
|
||||
@ -481,13 +473,6 @@ public class SyntaxTreeGenerator{
|
||||
genericParams, superClass, true, extendedInterfaces, ctx.getStart());
|
||||
}
|
||||
|
||||
private GenericDeclarationList createEmptyGenericDeclarationList(TerminalNode classNameIdentifier) {
|
||||
CommonToken gtvOffset = new CommonToken(classNameIdentifier.getSymbol());
|
||||
gtvOffset.setCharPositionInLine(gtvOffset.getCharPositionInLine()+classNameIdentifier.getText().length());
|
||||
gtvOffset.setStartIndex(gtvOffset.getStopIndex()+1);
|
||||
return new GenericDeclarationList(new ArrayList<>(), gtvOffset);
|
||||
}
|
||||
|
||||
private GenericsRegistry createGenerics(Java8Parser.TypeParametersContext ctx, JavaClassName parentClass, String parentMethod) {
|
||||
GenericsRegistry ret = new GenericsRegistry();
|
||||
if(ctx == null || ctx.typeParameterList() == null)return ret;
|
||||
@ -503,11 +488,11 @@ public class SyntaxTreeGenerator{
|
||||
}
|
||||
|
||||
private List<Method> convertMethods(Java8Parser.InterfaceBodyContext interfaceBodyContext,
|
||||
JavaClassName parentClass, RefType superClass, GenericsRegistry generics) {
|
||||
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, superClass, generics));
|
||||
ret.add(this.convert(member.interfaceMethodDeclaration(), parentClass, generics));
|
||||
//new Method(name, type, modifier, params, null, genericDecls, member.interfaceMethodDeclaration().getStart());
|
||||
}else{
|
||||
throw new NotImplementedException();
|
||||
|
@ -4,6 +4,7 @@ import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.exceptions.TypeinferenceException;
|
||||
import de.dhbwstuttgart.parser.NullToken;
|
||||
import de.dhbwstuttgart.parser.antlr.Java8Parser;
|
||||
import de.dhbwstuttgart.syntaxtree.GTVDeclarationContext;
|
||||
import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
|
||||
import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
|
||||
import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
|
||||
@ -18,7 +19,6 @@ import de.dhbwstuttgart.typecheck.JavaClassRegistry;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
public class TypeGenerator {
|
||||
@ -54,8 +54,10 @@ public class TypeGenerator {
|
||||
return TypeGenerator.convert(unannTypeContext.unannReferenceType().unannClassOrInterfaceType(), reg, genericsRegistry);
|
||||
}
|
||||
|
||||
public static GenericDeclarationList convert(Java8Parser.TypeParametersContext typeParametersContext,
|
||||
JavaClassName parentClass, String parentMethod, JavaClassRegistry reg, GenericsRegistry generics) {
|
||||
public static GenericDeclarationList convert(Java8Parser.TypeParametersContext typeParametersContext, JavaClassName parentClass, String parentMethod, JavaClassRegistry reg, GenericsRegistry generics) {
|
||||
if(typeParametersContext == null){
|
||||
return new GenericDeclarationList(new ArrayList<>(), new NullToken());
|
||||
}
|
||||
Token endOffset = typeParametersContext.getStop();
|
||||
List<GenericTypeVar> typeVars = new ArrayList<>();
|
||||
for(Java8Parser.TypeParameterContext typeParameter : typeParametersContext.typeParameterList().typeParameter()){
|
||||
@ -77,7 +79,7 @@ public class TypeGenerator {
|
||||
public static List<RefTypeOrTPHOrWildcardOrGeneric> convert(Java8Parser.TypeBoundContext typeBoundContext, JavaClassRegistry reg, GenericsRegistry generics) {
|
||||
if(typeBoundContext == null){
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> ret = new ArrayList<>();
|
||||
ret.add(ASTFactory.createObjectClass().getType());
|
||||
ret.add(new ASTFactory(reg).createObjectClass().getType());
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -94,7 +96,7 @@ public class TypeGenerator {
|
||||
|
||||
public static RefTypeOrTPHOrWildcardOrGeneric convertTypeName(
|
||||
String name, Java8Parser.TypeArgumentsContext typeArguments, Token offset, JavaClassRegistry reg, GenericsRegistry generics){
|
||||
if(!reg.contains(name)){ //Dann könnte es ein Generische Type sein
|
||||
if(!reg.contains(name)){ //Dann könnte es ein Generische Type sein:
|
||||
if(generics.keySet().contains(name)){
|
||||
return new GenericRefType(new GenericTypeName(generics.get(name),name), offset);
|
||||
}else{
|
||||
|
@ -180,7 +180,7 @@ public class Java8Parser extends Parser {
|
||||
"methodInvocation_lf_primary", "methodInvocation_lfno_primary", "argumentList",
|
||||
"methodReference", "methodReference_lf_primary", "methodReference_lfno_primary",
|
||||
"arrayCreationExpression", "dimExprs", "dimExpr", "constantExpression",
|
||||
"name", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList",
|
||||
"expression", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList",
|
||||
"lambdaBody", "assignmentExpression", "assignment", "leftHandSide", "assignmentOperator",
|
||||
"conditionalExpression", "conditionalOrExpression", "conditionalAndExpression",
|
||||
"inclusiveOrExpression", "exclusiveOrExpression", "andExpression", "equalityExpression",
|
||||
|
@ -1,40 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.statement.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Constraint;
|
||||
|
||||
public interface ASTVisitor extends StatementVisitor{
|
||||
|
||||
void visit(SourceFile sourceFile);
|
||||
|
||||
void visit(GenericTypeVar genericTypeVar);
|
||||
|
||||
void visit(FormalParameter formalParameter);
|
||||
|
||||
void visit(GenericDeclarationList genericTypeVars);
|
||||
|
||||
void visit(Field field);
|
||||
|
||||
void visit(Method field);
|
||||
|
||||
void visit(Constructor field);
|
||||
|
||||
void visit(ParameterList formalParameters);
|
||||
|
||||
void visit(ClassOrInterface classOrInterface);
|
||||
|
||||
void visit(RefType refType);
|
||||
|
||||
void visit(SuperWildcardType superWildcardType);
|
||||
|
||||
void visit(TypePlaceholder typePlaceholder);
|
||||
|
||||
void visit(ExtendsWildcardType extendsWildcardType);
|
||||
|
||||
void visit(GenericRefType genericRefType);
|
||||
|
||||
void visit(BreakStmt breakStmt);
|
||||
}
|
@ -1,275 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.util.Iterator;
|
||||
|
||||
public abstract class AbstractASTWalker implements ASTVisitor{
|
||||
@Override
|
||||
public void visit(Constructor cons) {
|
||||
visitMethod(cons);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SourceFile sourceFile) {
|
||||
for(ClassOrInterface cl : sourceFile.getClasses()){
|
||||
cl.accept(this);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ArgumentList argumentList) {
|
||||
for(Expression expr : argumentList.getArguments()){
|
||||
expr.accept(this);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(GenericTypeVar genericTypeVar) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(FormalParameter formalParameter) {
|
||||
formalParameter.getType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(GenericDeclarationList genericTypeVars) {
|
||||
Iterator<GenericTypeVar> genericIterator = genericTypeVars.iterator();
|
||||
if(genericIterator.hasNext()){
|
||||
while(genericIterator.hasNext()){
|
||||
genericIterator.next().accept(this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Field field) {
|
||||
field.getType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Method method) {
|
||||
visitMethod(method);
|
||||
}
|
||||
|
||||
private void visitMethod(Method method){
|
||||
method.getType().accept(this);
|
||||
method.getParameterList().accept(this);
|
||||
if(method.block != null)
|
||||
method.block.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ParameterList formalParameters) {
|
||||
Iterator<FormalParameter> genericIterator = formalParameters.getFormalparalist().iterator();
|
||||
if(genericIterator.hasNext()){
|
||||
while(genericIterator.hasNext()){
|
||||
genericIterator.next().accept(this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ClassOrInterface classOrInterface) {
|
||||
classOrInterface.getGenerics().accept(this);
|
||||
for(Field f : classOrInterface.getFieldDecl()){
|
||||
f.accept(this);
|
||||
}
|
||||
for(Method m : classOrInterface.getMethods()){
|
||||
m.accept(this);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(RefType refType) {
|
||||
Iterator<RefTypeOrTPHOrWildcardOrGeneric> genericIterator = refType.getParaList().iterator();
|
||||
if(genericIterator.hasNext()){
|
||||
while(genericIterator.hasNext()){
|
||||
genericIterator.next().accept(this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SuperWildcardType superWildcardType) {
|
||||
superWildcardType.getInnerType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(TypePlaceholder typePlaceholder) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ExtendsWildcardType extendsWildcardType) {
|
||||
extendsWildcardType.getInnerType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(GenericRefType genericRefType) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(LambdaExpression lambdaExpression) {
|
||||
lambdaExpression.params.accept(this);
|
||||
lambdaExpression.methodBody.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Assign assign) {
|
||||
assign.lefSide.accept(this);
|
||||
assign.rightSide.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Binary binary) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Block block) {
|
||||
for(Statement stmt : block.getStatements()){
|
||||
stmt.accept(this);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(CastExpr castExpr) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(EmptyStmt emptyStmt) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(FieldVar fieldVar) {
|
||||
fieldVar.receiver.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ForStmt forStmt) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(IfStmt ifStmt) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(InstanceOf instanceOf) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(LocalVar localVar) {
|
||||
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void visit(LocalVarDecl localVarDecl) {
|
||||
localVarDecl.getType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(MethodCall methodCall) {
|
||||
methodCall.receiver.accept(this);
|
||||
methodCall.getArgumentList().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(NewClass methodCall) {
|
||||
visit((MethodCall) methodCall);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(NewArray newArray) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Receiver receiver) {
|
||||
receiver.expr.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Return aReturn) {
|
||||
aReturn.retexpr.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ReturnVoid aReturn) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(StaticClassName staticClassName) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Super aSuper) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(This aThis) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(UnaryPlus unaryPlus) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(WhileStmt whileStmt) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(DoStmt whileStmt) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Null aNull) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Literal literal) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(AssignToField assignLeftSide) {
|
||||
assignLeftSide.field.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(AssignToLocal assignLeftSide) {
|
||||
assignLeftSide.localVar.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SuperCall superCall) {
|
||||
this.visit((MethodCall)superCall);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(BreakStmt breakStmt) {
|
||||
}
|
||||
}
|
@ -2,7 +2,6 @@ package de.dhbwstuttgart.syntaxtree;
|
||||
|
||||
import de.dhbwstuttgart.core.IItemWithOffset;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassName;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Constraint;
|
||||
@ -16,12 +15,13 @@ import java.util.List;
|
||||
/**
|
||||
* Stellt jede Art von Klasse dar. Auch abstrakte Klassen und Interfaces
|
||||
*/
|
||||
public class ClassOrInterface extends SyntaxTreeNode {
|
||||
public class ClassOrInterface extends GTVDeclarationContext implements IItemWithOffset, Generic{
|
||||
protected int modifiers;
|
||||
protected JavaClassName name;
|
||||
private List<Field> fields = new ArrayList<>();
|
||||
private List<Method> methods = new ArrayList<>();
|
||||
private GenericDeclarationList genericClassParameters;
|
||||
private Token offset;
|
||||
private RefTypeOrTPHOrWildcardOrGeneric superClass;
|
||||
protected boolean isInterface;
|
||||
private List<? extends RefTypeOrTPHOrWildcardOrGeneric> implementedInterfaces;
|
||||
@ -31,12 +31,23 @@ public class ClassOrInterface extends SyntaxTreeNode {
|
||||
RefTypeOrTPHOrWildcardOrGeneric superClass, Boolean isInterface, List<? extends RefTypeOrTPHOrWildcardOrGeneric> implementedInterfaces, Token offset){
|
||||
super(offset);
|
||||
this.modifiers = modifiers;
|
||||
if(name != null){
|
||||
this.name = name;
|
||||
}
|
||||
if(fielddecl != null){
|
||||
this.fields = fielddecl;
|
||||
this.genericClassParameters = genericClassParameters;
|
||||
}
|
||||
if(genericClassParameters != null){
|
||||
this.genericClassParameters = genericClassParameters;
|
||||
}
|
||||
this.offset = offset;
|
||||
if(superClass != null){
|
||||
this.superClass = superClass;
|
||||
}
|
||||
this.isInterface = isInterface;
|
||||
if(implementedInterfaces != null){
|
||||
this.implementedInterfaces = implementedInterfaces;
|
||||
}
|
||||
this.methods = methods;
|
||||
this.constructors = constructors;
|
||||
}
|
||||
@ -58,6 +69,14 @@ public class ClassOrInterface extends SyntaxTreeNode {
|
||||
return this.methods;
|
||||
}
|
||||
|
||||
public ConstraintSet getConstraints(TypeInferenceInformation info) {
|
||||
ConstraintSet ret = new ConstraintSet();
|
||||
for(Method m : this.getMethods()){
|
||||
ret.addAll(m.getConstraints(info, this));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
public RefType getType() {
|
||||
return generateTypeOfClass(this.getClassName(), this.getGenerics(), this.getOffset());
|
||||
}
|
||||
@ -74,12 +93,7 @@ public class ClassOrInterface extends SyntaxTreeNode {
|
||||
return this.genericClassParameters;
|
||||
}
|
||||
|
||||
public List<Constructor> getConstructors() {
|
||||
public List<? extends Method> getConstructors() {
|
||||
return constructors;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
@ -1,38 +1,14 @@
|
||||
package de.dhbwstuttgart.syntaxtree;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Statement;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.SuperCall;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Block;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class Constructor extends Method {
|
||||
|
||||
|
||||
//TODO: Constructor braucht ein super-Statement
|
||||
public Constructor(String name, RefTypeOrTPHOrWildcardOrGeneric returnType, int modifiers, ParameterList parameterList, Block codeInsideConstructor,
|
||||
GenericDeclarationList gtvDeclarations, Token offset, List<Statement> fieldInitializations, RefType superClass) {
|
||||
super(name, returnType, modifiers, parameterList, prepareBlock(codeInsideConstructor,fieldInitializations, superClass), gtvDeclarations, offset);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @param fieldInitializations - Das sind die Statements,
|
||||
* welche die Felder der zugehörigen Klasse dieses
|
||||
* Konstruktor initialisieren
|
||||
*/
|
||||
protected static Block prepareBlock(Block constructorBlock, List<Statement> fieldInitializations, RefType superClass){
|
||||
List<Statement> statements = constructorBlock.getStatements();
|
||||
statements.add(0, new SuperCall(constructorBlock.getOffset()));
|
||||
return new Block(statements, constructorBlock.getOffset());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
public Constructor(String name, RefTypeOrTPHOrWildcardOrGeneric returnType, int modifiers, ParameterList parameterList, Block block, GenericDeclarationList gtvDeclarations, Token offset) {
|
||||
super(name, returnType, modifiers, parameterList, block, gtvDeclarations, offset);
|
||||
}
|
||||
}
|
||||
|
@ -3,7 +3,7 @@ package de.dhbwstuttgart.syntaxtree;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public class Field extends SyntaxTreeNode{
|
||||
public class Field extends GTVDeclarationContext implements Generic {
|
||||
|
||||
private String name;
|
||||
private RefTypeOrTPHOrWildcardOrGeneric type;
|
||||
@ -24,10 +24,5 @@ public class Field extends SyntaxTreeNode{
|
||||
public RefTypeOrTPHOrWildcardOrGeneric getType() {
|
||||
return type;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -17,13 +17,4 @@ public class FormalParameter extends SyntaxTreeNode
|
||||
public RefTypeOrTPHOrWildcardOrGeneric getType() {
|
||||
return type;
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
13
src/de/dhbwstuttgart/syntaxtree/GTVDeclarationContext.java
Normal file
13
src/de/dhbwstuttgart/syntaxtree/GTVDeclarationContext.java
Normal file
@ -0,0 +1,13 @@
|
||||
package de.dhbwstuttgart.syntaxtree;
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
/**
|
||||
* Beischreibt eine SyntaxTreeNode, welcher die Eigenschaft besitzt,
|
||||
* dass bei seiner Deklaration auch Generische Typvariablen deklariert wurden.
|
||||
*/
|
||||
public abstract class GTVDeclarationContext extends SyntaxTreeNode {
|
||||
public GTVDeclarationContext(Token offset) {
|
||||
super(offset);
|
||||
}
|
||||
}
|
9
src/de/dhbwstuttgart/syntaxtree/Generic.java
Normal file
9
src/de/dhbwstuttgart/syntaxtree/Generic.java
Normal file
@ -0,0 +1,9 @@
|
||||
package de.dhbwstuttgart.syntaxtree;
|
||||
|
||||
/**
|
||||
* Wird von allen Klassen implementiert, welche generische Parameter halten können. (Class, Method und Field)
|
||||
* @author janulrich
|
||||
*
|
||||
*/
|
||||
public interface Generic {
|
||||
}
|
@ -26,9 +26,4 @@ public class GenericDeclarationList extends SyntaxTreeNode implements Iterable<G
|
||||
public Iterator<GenericTypeVar> iterator() {
|
||||
return gtvs.iterator();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
@ -51,9 +51,4 @@ public class GenericTypeVar extends SyntaxTreeNode
|
||||
public GenericTypeName getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
@ -8,7 +8,6 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
|
||||
import de.dhbwstuttgart.typeinference.typeAlgo.TYPE;
|
||||
import de.dhbwstuttgart.typeinference.typeAlgo.TYPEStmt;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import de.dhbwstuttgart.core.IItemWithOffset;
|
||||
@ -24,7 +23,7 @@ import de.dhbwstuttgart.syntaxtree.statement.Block;
|
||||
*/
|
||||
public class Method extends Field implements IItemWithOffset, TypeScope
|
||||
{
|
||||
public final Block block;
|
||||
private Block block;
|
||||
private ParameterList parameterlist = new ParameterList(new ArrayList<>(), new NullToken());
|
||||
private ExceptionList exceptionlist;
|
||||
private GenericDeclarationList generics;
|
||||
@ -37,6 +36,14 @@ public class Method extends Field implements IItemWithOffset, TypeScope
|
||||
this.generics = gtvDeclarations;
|
||||
}
|
||||
|
||||
public ConstraintSet getConstraints(TypeInferenceInformation info, ClassOrInterface currentClass) {
|
||||
if(block == null)return new ConstraintSet(); //Abstrakte Methoden generieren keine Constraints
|
||||
TypeInferenceBlockInformation blockInfo = new TypeInferenceBlockInformation(info.getAvailableClasses(), currentClass, this);
|
||||
TYPE methodScope = new TYPE(blockInfo);
|
||||
block.accept(methodScope);
|
||||
return methodScope.getConstraints();
|
||||
}
|
||||
|
||||
public ParameterList getParameterList() {
|
||||
return parameterlist;
|
||||
}
|
||||
@ -49,9 +56,4 @@ public class Method extends Field implements IItemWithOffset, TypeScope
|
||||
public RefTypeOrTPHOrWildcardOrGeneric getReturnType() {
|
||||
return this.getType();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
@ -32,11 +32,6 @@ public class ParameterList extends SyntaxTreeNode implements Iterable<FormalPara
|
||||
|
||||
@Override
|
||||
public Iterator<FormalParameter> iterator() {
|
||||
return formalparameter.iterator();
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
@ -7,24 +7,26 @@ import de.dhbwstuttgart.parser.NullToken;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassName;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
|
||||
//import sun.security.x509.X509CertInfo;
|
||||
import sun.security.x509.X509CertInfo;
|
||||
|
||||
|
||||
public class SourceFile extends SyntaxTreeNode{
|
||||
private String pkgName;
|
||||
|
||||
public final List<ClassOrInterface> KlassenVektor;
|
||||
public final List<JavaClassName> imports;
|
||||
private final List<ClassOrInterface> KlassenVektor;
|
||||
private final List<JavaClassName> imports;
|
||||
private final File file;
|
||||
|
||||
/**
|
||||
* Die SourceFile repräsntiert eine zu einem Syntaxbaum eingelesene Java-Datei.
|
||||
* SourceFile stellt dabei den Wurzelknoten des Syntaxbaumes dar.
|
||||
*/
|
||||
public SourceFile(String pkgName, List<ClassOrInterface> classDefinitions, List<JavaClassName> imports){
|
||||
public SourceFile(File file, String pkgName, List<ClassOrInterface> classDefinitions, List<JavaClassName> imports){
|
||||
super(new NullToken());
|
||||
this.KlassenVektor = classDefinitions;
|
||||
this.pkgName = pkgName;
|
||||
this.imports = imports;
|
||||
this.file = file;
|
||||
}
|
||||
|
||||
public String getPkgName(){
|
||||
@ -36,12 +38,28 @@ public class SourceFile extends SyntaxTreeNode{
|
||||
return this.imports;
|
||||
}
|
||||
|
||||
public ConstraintSet getConstraints(TypeInferenceInformation info) {
|
||||
ConstraintSet ret = new ConstraintSet();
|
||||
for (ClassOrInterface cl : this.KlassenVektor) {
|
||||
ret.addAll(cl.getConstraints(info));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
public TypeInferenceInformation getTypeInferenceInformation(List<SourceFile> sourceFiles){
|
||||
Set<ClassOrInterface> classes = new HashSet<>();
|
||||
for(SourceFile sourceFile : sourceFiles){
|
||||
classes.addAll(sourceFile.KlassenVektor);
|
||||
}
|
||||
|
||||
return new TypeInferenceInformation(classes);
|
||||
}
|
||||
|
||||
public List<ClassOrInterface> getClasses() {
|
||||
return KlassenVektor;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
public File getFile() {
|
||||
return file;
|
||||
}
|
||||
}
|
||||
|
@ -1,6 +1,5 @@
|
||||
package de.dhbwstuttgart.syntaxtree;
|
||||
|
||||
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
|
||||
@ -8,8 +7,6 @@ import de.dhbwstuttgart.syntaxtree.statement.literal.StringLiteral;
|
||||
|
||||
public interface StatementVisitor {
|
||||
|
||||
void visit(ArgumentList argumentList);
|
||||
|
||||
void visit(LambdaExpression lambdaExpression);
|
||||
|
||||
void visit(Assign assign);
|
||||
@ -18,8 +15,6 @@ public interface StatementVisitor {
|
||||
|
||||
void visit(Block block);
|
||||
|
||||
void visit(BreakStmt breakStmt);
|
||||
|
||||
void visit(CastExpr castExpr);
|
||||
|
||||
void visit(EmptyStmt emptyStmt);
|
||||
@ -32,6 +27,8 @@ public interface StatementVisitor {
|
||||
|
||||
void visit(InstanceOf instanceOf);
|
||||
|
||||
void visit(InstVar instVar);
|
||||
|
||||
void visit(LocalVar localVar);
|
||||
|
||||
void visit(LocalVarDecl localVarDecl);
|
||||
@ -58,15 +55,7 @@ public interface StatementVisitor {
|
||||
|
||||
void visit(WhileStmt whileStmt);
|
||||
|
||||
void visit(DoStmt whileStmt);
|
||||
|
||||
void visit(Null aNull);
|
||||
|
||||
void visit(Literal literal);
|
||||
|
||||
void visit(AssignToField assignLeftSide);
|
||||
|
||||
void visit(AssignToLocal assignLeftSide);
|
||||
|
||||
void visit(SuperCall superCall);
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import java.util.List;
|
||||
import de.dhbwstuttgart.core.IItemWithOffset;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
//import org.antlr.v4.runtime.misc.Pair;
|
||||
import org.antlr.v4.runtime.misc.Pair;
|
||||
|
||||
public abstract class SyntaxTreeNode implements IItemWithOffset{
|
||||
private final Token offset;
|
||||
@ -19,5 +19,4 @@ public abstract class SyntaxTreeNode implements IItemWithOffset{
|
||||
return offset;
|
||||
}
|
||||
|
||||
public abstract void accept(ASTVisitor visitor);
|
||||
}
|
||||
|
@ -25,9 +25,15 @@ import org.antlr.v4.runtime.Token;
|
||||
* dass alle Imports und Typnamen korrekt sind und müssen diese nicht überprüfen.
|
||||
*/
|
||||
public class ASTFactory {
|
||||
private final JavaClassRegistry names;
|
||||
|
||||
public static ClassOrInterface createClass(java.lang.Class jreClass){
|
||||
JavaClassName name = new JavaClassName(jreClass.getName());
|
||||
|
||||
public ASTFactory(JavaClassRegistry scope){
|
||||
names = scope;
|
||||
}
|
||||
|
||||
public ClassOrInterface createClass(java.lang.Class jreClass){
|
||||
JavaClassName name = names.getName(jreClass.getName());
|
||||
List<Method> methoden = new ArrayList<>();
|
||||
List<de.dhbwstuttgart.syntaxtree.Constructor> konstruktoren = new ArrayList<>();
|
||||
for(java.lang.reflect.Constructor constructor : jreClass.getConstructors()){
|
||||
@ -37,9 +43,6 @@ public class ASTFactory {
|
||||
methoden.add(createMethod(method, jreClass));
|
||||
}
|
||||
List<Field> felder = new ArrayList<>();
|
||||
for(java.lang.reflect.Field field : jreClass.getFields()){
|
||||
felder.add(createField(field, name));
|
||||
}
|
||||
int modifier = jreClass.getModifiers();
|
||||
boolean isInterface = jreClass.isInterface();
|
||||
java.lang.Class superjreClass = jreClass.getSuperclass();
|
||||
@ -60,17 +63,13 @@ public class ASTFactory {
|
||||
return new ClassOrInterface(modifier, name, felder, methoden, konstruktoren, genericDeclarationList, superClass,isInterface, implementedInterfaces, offset);
|
||||
}
|
||||
|
||||
private static Field createField(java.lang.reflect.Field field, JavaClassName jreClass) {
|
||||
return new Field(field.getName(), createType(field.getType(), jreClass, null), field.getModifiers(), new NullToken());
|
||||
}
|
||||
|
||||
private static de.dhbwstuttgart.syntaxtree.Constructor createConstructor(Constructor constructor, Class inClass) {
|
||||
private de.dhbwstuttgart.syntaxtree.Constructor createConstructor(Constructor constructor, Class inClass) {
|
||||
String name = constructor.getName();
|
||||
RefTypeOrTPHOrWildcardOrGeneric returnType = createType(inClass, new JavaClassName(inClass.getName()), name);
|
||||
RefTypeOrTPHOrWildcardOrGeneric returnType = createType(inClass, names.getName(inClass.getName()), name);
|
||||
Parameter[] jreParams = constructor.getParameters();
|
||||
List<FormalParameter> params = new ArrayList<>();
|
||||
for(Parameter jreParam : jreParams){
|
||||
RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam.getType(),new JavaClassName(inClass.getName()), name);
|
||||
RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam.getType(),names.getName(inClass.getName()), name);
|
||||
params.add(new FormalParameter(jreParam.getName(),paramType, new NullToken()));
|
||||
}
|
||||
ParameterList parameterList = new ParameterList(params, new NullToken());
|
||||
@ -79,26 +78,17 @@ public class ASTFactory {
|
||||
Token offset = new NullToken();
|
||||
int modifier = constructor.getModifiers();
|
||||
|
||||
if(inClass.equals(java.lang.Object.class)){
|
||||
return null;
|
||||
}
|
||||
|
||||
return new de.dhbwstuttgart.syntaxtree.Constructor(name,returnType, modifier, parameterList, block, gtvDeclarations, offset, new ArrayList<>(),
|
||||
createType(inClass.getSuperclass()));
|
||||
return new de.dhbwstuttgart.syntaxtree.Constructor(name,returnType, modifier, parameterList, block, gtvDeclarations, offset);
|
||||
}
|
||||
|
||||
private static RefType createType(Class classType) {
|
||||
return createClass(classType).getType();
|
||||
}
|
||||
|
||||
public static Method createMethod(java.lang.reflect.Method jreMethod, java.lang.Class inClass){
|
||||
public Method createMethod(java.lang.reflect.Method jreMethod, java.lang.Class inClass){
|
||||
String name = jreMethod.getName();
|
||||
RefTypeOrTPHOrWildcardOrGeneric returnType;
|
||||
returnType = createType(jreMethod.getReturnType(),new JavaClassName(inClass.getName()), name);
|
||||
returnType = createType(jreMethod.getReturnType(),names.getName(inClass.getName()), name);
|
||||
Parameter[] jreParams = jreMethod.getParameters();
|
||||
List<FormalParameter> params = new ArrayList<>();
|
||||
for(Parameter jreParam : jreParams){
|
||||
RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam.getType(),new JavaClassName(inClass.getName()), name);
|
||||
RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam.getType(),names.getName(inClass.getName()), name);
|
||||
params.add(new FormalParameter(jreParam.getName(),paramType, new NullToken()));
|
||||
}
|
||||
ParameterList parameterList = new ParameterList(params, new NullToken());
|
||||
@ -110,7 +100,7 @@ public class ASTFactory {
|
||||
return new Method(name,returnType, modifier, parameterList, block, gtvDeclarations, offset);
|
||||
}
|
||||
|
||||
public static GenericDeclarationList createGenerics(TypeVariable[] typeParameters, Class context, String methodName){
|
||||
public GenericDeclarationList createGenerics(TypeVariable[] typeParameters, Class context, String methodName){
|
||||
List<de.dhbwstuttgart.syntaxtree.GenericTypeVar> gtvs = new ArrayList<>();
|
||||
for(TypeVariable jreTV : typeParameters){
|
||||
de.dhbwstuttgart.syntaxtree.GenericTypeVar gtv = createGeneric(jreTV, jreTV.getName(), context, methodName);
|
||||
@ -130,23 +120,23 @@ public class ASTFactory {
|
||||
}
|
||||
*/
|
||||
|
||||
public static RefTypeOrTPHOrWildcardOrGeneric createType(java.lang.reflect.Type type, JavaClassName parentClass, String parentMethod){
|
||||
public RefTypeOrTPHOrWildcardOrGeneric createType(java.lang.reflect.Type type, JavaClassName parentClass, String parentMethod){
|
||||
if(type.getTypeName().equals("void")){
|
||||
return new Void(new NullToken());
|
||||
}else if(type.getTypeName().equals("int")){
|
||||
return new RefType(new JavaClassName("java.lang.Integer"), new ArrayList<>(), new NullToken());
|
||||
return new RefType(this.names.getName("java.lang.Integer"), new ArrayList<>(), new NullToken());
|
||||
}else if(type.getTypeName().equals("byte")){
|
||||
return new RefType(new JavaClassName("java.lang.Byte"), new ArrayList<>(), new NullToken());
|
||||
return new RefType(this.names.getName("java.lang.Byte"), new ArrayList<>(), new NullToken());
|
||||
}else if(type.getTypeName().equals("boolean")){
|
||||
return new RefType(new JavaClassName("java.lang.Boolean"), new ArrayList<>(), new NullToken());
|
||||
return new RefType(this.names.getName("java.lang.Boolean"), new ArrayList<>(), new NullToken());
|
||||
}else if(type.getTypeName().equals("char")){
|
||||
return new RefType(new JavaClassName("java.lang.Char"), new ArrayList<>(), new NullToken());
|
||||
return new RefType(this.names.getName("java.lang.Char"), new ArrayList<>(), new NullToken());
|
||||
}else if(type.getTypeName().equals("short")){
|
||||
return new RefType(new JavaClassName("java.lang.Short"), new ArrayList<>(), new NullToken());
|
||||
return new RefType(this.names.getName("java.lang.Short"), new ArrayList<>(), new NullToken());
|
||||
}else if(type.getTypeName().equals("double")){
|
||||
return new RefType(new JavaClassName("java.lang.Double"), new ArrayList<>(), new NullToken());
|
||||
return new RefType(this.names.getName("java.lang.Double"), new ArrayList<>(), new NullToken());
|
||||
}else if(type.getTypeName().equals("long")){
|
||||
return new RefType(new JavaClassName("java.lang.Long"), new ArrayList<>(), new NullToken());
|
||||
return new RefType(this.names.getName("java.lang.Long"), new ArrayList<>(), new NullToken());
|
||||
}else{
|
||||
if(type instanceof TypeVariable){
|
||||
//GTVDeclarationContext via "(TypeVariable) type).getGenericDeclaration()"
|
||||
@ -160,13 +150,13 @@ public class ASTFactory {
|
||||
params.add(createType(t, parentClass, parentMethod));
|
||||
}
|
||||
}
|
||||
RefType ret = new RefType(new JavaClassName(type.getTypeName()), params, new NullToken());
|
||||
RefType ret = new RefType(this.names.getName(type.getTypeName()), params, new NullToken());
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
public static de.dhbwstuttgart.syntaxtree.GenericTypeVar createGeneric(TypeVariable jreTypeVar, String jreTVName, Class context, String parentMethod){
|
||||
JavaClassName parentClass = new JavaClassName(context.getName());
|
||||
public de.dhbwstuttgart.syntaxtree.GenericTypeVar createGeneric(TypeVariable jreTypeVar, String jreTVName, Class context, String parentMethod){
|
||||
JavaClassName parentClass = names.getName(context.getName());
|
||||
List<RefType> genericBounds = new ArrayList<>();
|
||||
java.lang.reflect.Type[] bounds = jreTypeVar.getBounds();
|
||||
if(bounds.length > 0){
|
||||
@ -179,8 +169,8 @@ public class ASTFactory {
|
||||
, genericBounds, new NullToken(), new NullToken());
|
||||
}
|
||||
|
||||
public static ClassOrInterface createObjectClass() {
|
||||
return createClass(Object.class);
|
||||
public ClassOrInterface createObjectClass() {
|
||||
return this.createClass(Object.class);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -11,9 +11,6 @@ import de.dhbwstuttgart.syntaxtree.type.Void;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassName;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Pair;
|
||||
import de.dhbwstuttgart.typeinference.result.PairTPHequalRefType;
|
||||
import de.dhbwstuttgart.typeinference.result.PairTPHsmallerTPH;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultPair;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.ExtendsType;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.FunNType;
|
||||
@ -121,39 +118,39 @@ public class UnifyTypeFactory {
|
||||
}
|
||||
|
||||
public static UnifyPair convert(Pair p) {
|
||||
if(p.GetOperator().equals(PairOperator.SMALLERDOT)) {
|
||||
if(p.OperatorSmaller()) {
|
||||
UnifyPair ret = generateSmallerDotPair(UnifyTypeFactory.convert(p.TA1)
|
||||
, UnifyTypeFactory.convert(p.TA2));
|
||||
return ret;
|
||||
}else if(p.GetOperator().equals(PairOperator.EQUALSDOT)){
|
||||
}else if(p.OperatorEqual()){
|
||||
UnifyPair ret = generateEqualDotPair(UnifyTypeFactory.convert(p.TA1)
|
||||
, UnifyTypeFactory.convert(p.TA2));
|
||||
return ret;
|
||||
}else throw new NotImplementedException();
|
||||
}else throw new NotImplementedException();
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert from
|
||||
* UnifyType -> ASTType
|
||||
*/
|
||||
public static Set<ResultPair> convert(Set<UnifyPair> unifyPairSet, Map<String,TypePlaceholder> tphs) {
|
||||
public static Set<Set<Pair>> convert(Set<Set<UnifyPair>> unifyPairSet, Map<String,TypePlaceholder> tphs) {
|
||||
return unifyPairSet.stream().map(
|
||||
unifyPair -> convert(unifyPair, tphs))
|
||||
.collect(Collectors.toSet());
|
||||
set -> set.stream().map(
|
||||
unifyPair -> convert(unifyPair, tphs))
|
||||
.collect(Collectors.toSet()))
|
||||
.collect(Collectors.toSet());
|
||||
}
|
||||
|
||||
public static ResultPair convert(UnifyPair mp, Map<String,TypePlaceholder> tphs) {
|
||||
public static Pair convert(UnifyPair mp, Map<String,TypePlaceholder> tphs) {
|
||||
RefTypeOrTPHOrWildcardOrGeneric tl = UnifyTypeFactory.convert(mp.getLhsType(), tphs);
|
||||
RefTypeOrTPHOrWildcardOrGeneric tr = UnifyTypeFactory.convert(mp.getRhsType(), tphs);
|
||||
if(tl instanceof TypePlaceholder){
|
||||
if(tr instanceof TypePlaceholder) return new PairTPHsmallerTPH((TypePlaceholder)tl, (TypePlaceholder)tr);
|
||||
return new PairTPHequalRefType((TypePlaceholder)tl, tr);
|
||||
}else throw new NotImplementedException();
|
||||
return new Pair(tl, tr, mp.getPairOp());
|
||||
}
|
||||
|
||||
public static RefTypeOrTPHOrWildcardOrGeneric convert(ReferenceType t, Map<String,TypePlaceholder> tphs) {
|
||||
if(JavaClassName.Void.equals(t.getName()))return new Void(new NullToken());
|
||||
RefType ret = new RefType(new JavaClassName(t.getName()),convert(t.getTypeParams(), tphs),new NullToken());
|
||||
RefType ret = new RefType(JavaClassName.Void,convert(t.getTypeParams(), tphs),new NullToken());
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -163,12 +160,12 @@ public class UnifyTypeFactory {
|
||||
}
|
||||
|
||||
public static RefTypeOrTPHOrWildcardOrGeneric convert(SuperType t, Map<String,TypePlaceholder> tphs) {
|
||||
RefTypeOrTPHOrWildcardOrGeneric innerType = convert(t.getSuperedType(), tphs);
|
||||
RefType innerType = new RefType(new JavaClassName(t.getSuperedType().getName()), new NullToken());
|
||||
return new SuperWildcardType(innerType, new NullToken());
|
||||
}
|
||||
|
||||
public static RefTypeOrTPHOrWildcardOrGeneric convert(ExtendsType t, Map<String,TypePlaceholder> tphs) {
|
||||
RefTypeOrTPHOrWildcardOrGeneric innerType = convert(t.getExtendedType(), tphs);
|
||||
RefType innerType = new RefType(new JavaClassName(t.getExtendedType().getName()), new NullToken());
|
||||
return new ExtendsWildcardType(innerType, new NullToken());
|
||||
}
|
||||
|
||||
@ -176,7 +173,6 @@ public class UnifyTypeFactory {
|
||||
TypePlaceholder ret = tphs.get(t.getName());
|
||||
if(ret == null){ //Dieser TPH wurde vom Unifikationsalgorithmus erstellt
|
||||
ret = TypePlaceholder.fresh(new NullToken());
|
||||
tphs.put(t.getName(), ret);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
23
src/de/dhbwstuttgart/syntaxtree/operator/AddOp.java
Executable file
23
src/de/dhbwstuttgart/syntaxtree/operator/AddOp.java
Executable file
@ -0,0 +1,23 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
import java.util.HashMap;
|
||||
import java.util.Hashtable;
|
||||
import java.util.Iterator;
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
import org.apache.bcel.Constants;
|
||||
import org.apache.bcel.generic.ArithmeticInstruction;
|
||||
import org.apache.bcel.generic.DUP;
|
||||
import org.apache.bcel.generic.IADD;
|
||||
import org.apache.bcel.generic.InstructionList;
|
||||
import org.apache.bcel.generic.InvokeInstruction;
|
||||
import org.apache.bcel.generic.ObjectType;
|
||||
|
||||
|
||||
|
||||
public abstract class AddOp extends Operator
|
||||
{
|
||||
public AddOp(Token offset) {
|
||||
super(offset);
|
||||
}
|
||||
|
||||
}
|
18
src/de/dhbwstuttgart/syntaxtree/operator/AndOp.java
Executable file
18
src/de/dhbwstuttgart/syntaxtree/operator/AndOp.java
Executable file
@ -0,0 +1,18 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Binary;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
import org.apache.bcel.generic.InstructionList;
|
||||
|
||||
public class AndOp extends LogOp
|
||||
{
|
||||
|
||||
public AndOp(Token offset)
|
||||
{
|
||||
super(offset);
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
12
src/de/dhbwstuttgart/syntaxtree/operator/DivideOp.java
Executable file
12
src/de/dhbwstuttgart/syntaxtree/operator/DivideOp.java
Executable file
@ -0,0 +1,12 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
|
||||
|
||||
public class DivideOp extends MulOp
|
||||
{
|
||||
public DivideOp(Token offset) {
|
||||
super(offset);
|
||||
}
|
||||
}
|
15
src/de/dhbwstuttgart/syntaxtree/operator/EqualOp.java
Executable file
15
src/de/dhbwstuttgart/syntaxtree/operator/EqualOp.java
Executable file
@ -0,0 +1,15 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
import org.apache.bcel.generic.BranchInstruction;
|
||||
import org.apache.bcel.generic.IF_ICMPNE;
|
||||
|
||||
|
||||
public class EqualOp extends RelOp
|
||||
{
|
||||
|
||||
|
||||
public EqualOp(Token offset) {
|
||||
super(offset);
|
||||
}
|
||||
}
|
13
src/de/dhbwstuttgart/syntaxtree/operator/GreaterEquOp.java
Executable file
13
src/de/dhbwstuttgart/syntaxtree/operator/GreaterEquOp.java
Executable file
@ -0,0 +1,13 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
|
||||
|
||||
public class GreaterEquOp extends RelOp
|
||||
{
|
||||
|
||||
public GreaterEquOp(Token offset) {
|
||||
super(offset);
|
||||
}
|
||||
}
|
14
src/de/dhbwstuttgart/syntaxtree/operator/GreaterOp.java
Executable file
14
src/de/dhbwstuttgart/syntaxtree/operator/GreaterOp.java
Executable file
@ -0,0 +1,14 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
|
||||
|
||||
|
||||
public class GreaterOp extends RelOp
|
||||
{
|
||||
|
||||
|
||||
public GreaterOp(Token offset) {
|
||||
super(offset);
|
||||
}
|
||||
}
|
15
src/de/dhbwstuttgart/syntaxtree/operator/LessEquOp.java
Executable file
15
src/de/dhbwstuttgart/syntaxtree/operator/LessEquOp.java
Executable file
@ -0,0 +1,15 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
|
||||
|
||||
|
||||
public class LessEquOp extends RelOp
|
||||
{
|
||||
|
||||
|
||||
public LessEquOp(Token offset) {
|
||||
super(offset);
|
||||
}
|
||||
}
|
14
src/de/dhbwstuttgart/syntaxtree/operator/LessOp.java
Executable file
14
src/de/dhbwstuttgart/syntaxtree/operator/LessOp.java
Executable file
@ -0,0 +1,14 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
|
||||
|
||||
|
||||
public class LessOp extends RelOp
|
||||
{
|
||||
public LessOp(Token offset)
|
||||
{
|
||||
super(offset);
|
||||
}
|
||||
|
||||
}
|
18
src/de/dhbwstuttgart/syntaxtree/operator/LogOp.java
Executable file
18
src/de/dhbwstuttgart/syntaxtree/operator/LogOp.java
Executable file
@ -0,0 +1,18 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Hashtable;
|
||||
import java.util.Iterator;
|
||||
|
||||
|
||||
|
||||
public abstract class LogOp extends Operator
|
||||
{
|
||||
|
||||
public LogOp(Token offset)
|
||||
{
|
||||
super(offset);
|
||||
}
|
||||
|
||||
}
|
11
src/de/dhbwstuttgart/syntaxtree/operator/MinusOp.java
Executable file
11
src/de/dhbwstuttgart/syntaxtree/operator/MinusOp.java
Executable file
@ -0,0 +1,11 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public class MinusOp extends AddOp
|
||||
{
|
||||
public MinusOp(Token offset) {
|
||||
super(offset);
|
||||
}
|
||||
}
|
15
src/de/dhbwstuttgart/syntaxtree/operator/ModuloOp.java
Executable file
15
src/de/dhbwstuttgart/syntaxtree/operator/ModuloOp.java
Executable file
@ -0,0 +1,15 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
|
||||
|
||||
|
||||
public class ModuloOp extends MulOp
|
||||
{
|
||||
public ModuloOp(Token offset)
|
||||
{
|
||||
super(offset);
|
||||
}
|
||||
|
||||
}
|
10
src/de/dhbwstuttgart/syntaxtree/operator/MulOp.java
Executable file
10
src/de/dhbwstuttgart/syntaxtree/operator/MulOp.java
Executable file
@ -0,0 +1,10 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public abstract class MulOp extends Operator
|
||||
{
|
||||
public MulOp(Token offset) {
|
||||
super(offset);
|
||||
}
|
||||
}
|
11
src/de/dhbwstuttgart/syntaxtree/operator/NotEqualOp.java
Executable file
11
src/de/dhbwstuttgart/syntaxtree/operator/NotEqualOp.java
Executable file
@ -0,0 +1,11 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public class NotEqualOp extends RelOp
|
||||
{
|
||||
|
||||
public NotEqualOp(Token offset) {
|
||||
super(offset);
|
||||
}
|
||||
}
|
13
src/de/dhbwstuttgart/syntaxtree/operator/Operator.java
Executable file
13
src/de/dhbwstuttgart/syntaxtree/operator/Operator.java
Executable file
@ -0,0 +1,13 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public abstract class Operator extends SyntaxTreeNode
|
||||
{
|
||||
|
||||
public Operator(Token offset) {
|
||||
super(offset);
|
||||
}
|
||||
}
|
15
src/de/dhbwstuttgart/syntaxtree/operator/OrOp.java
Executable file
15
src/de/dhbwstuttgart/syntaxtree/operator/OrOp.java
Executable file
@ -0,0 +1,15 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
|
||||
public class OrOp extends LogOp
|
||||
{
|
||||
|
||||
public OrOp(Token offset)
|
||||
{
|
||||
super(offset);
|
||||
}
|
||||
|
||||
|
||||
}
|
12
src/de/dhbwstuttgart/syntaxtree/operator/PlusOp.java
Executable file
12
src/de/dhbwstuttgart/syntaxtree/operator/PlusOp.java
Executable file
@ -0,0 +1,12 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public class PlusOp extends AddOp
|
||||
{
|
||||
public PlusOp(Token offset)
|
||||
{
|
||||
super(offset);
|
||||
}
|
||||
}
|
11
src/de/dhbwstuttgart/syntaxtree/operator/RelOp.java
Executable file
11
src/de/dhbwstuttgart/syntaxtree/operator/RelOp.java
Executable file
@ -0,0 +1,11 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public abstract class RelOp extends Operator
|
||||
{
|
||||
|
||||
public RelOp(Token offset) {
|
||||
super(offset);
|
||||
}
|
||||
}
|
11
src/de/dhbwstuttgart/syntaxtree/operator/TimesOp.java
Executable file
11
src/de/dhbwstuttgart/syntaxtree/operator/TimesOp.java
Executable file
@ -0,0 +1,11 @@
|
||||
package de.dhbwstuttgart.syntaxtree.operator;
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public class TimesOp extends MulOp
|
||||
{
|
||||
public TimesOp(Token offset)
|
||||
{
|
||||
super(offset);
|
||||
}
|
||||
}
|
@ -1,7 +1,6 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
@ -20,8 +19,4 @@ public class ArgumentList extends SyntaxTreeNode
|
||||
return expr;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
@ -1,24 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Created by Felix_K on 21.09.2017.
|
||||
*/
|
||||
public class AssertStmt extends Statement
|
||||
{
|
||||
public final List<Expression> expr;
|
||||
public AssertStmt(RefTypeOrTPHOrWildcardOrGeneric type, List<Expression> expr, Token offset){
|
||||
super(type, offset);
|
||||
this.expr=expr;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
|
||||
}
|
||||
}
|
@ -8,16 +8,13 @@ import de.dhbwstuttgart.typeinference.constraints.ConstraintsFactory;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
/*
|
||||
Aufbau:
|
||||
rightSide = leftSide
|
||||
*/
|
||||
|
||||
public class Assign extends Statement
|
||||
{
|
||||
public final Expression rightSide;
|
||||
public final AssignLeftSide lefSide;
|
||||
public final Expression lefSide;
|
||||
|
||||
public Assign(AssignLeftSide leftHandSide, Expression value, Token offset) {
|
||||
public Assign(Expression leftHandSide, Expression value, Token offset) {
|
||||
super(leftHandSide.getType(), offset);
|
||||
this.rightSide = value;
|
||||
this.lefSide = leftHandSide;
|
||||
|
@ -1,12 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public abstract class AssignLeftSide extends TypableStatement{
|
||||
|
||||
public AssignLeftSide(RefTypeOrTPHOrWildcardOrGeneric type, Token offset) {
|
||||
super(type, offset);
|
||||
}
|
||||
}
|
@ -1,16 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
|
||||
public class AssignToField extends AssignLeftSide{
|
||||
public final FieldVar field;
|
||||
public AssignToField(FieldVar fieldVar) {
|
||||
super(fieldVar.getType(), fieldVar.getOffset());
|
||||
field = fieldVar;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
@ -6,16 +6,12 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.operator.Operator;
|
||||
|
||||
|
||||
// neu von Felix
|
||||
public class Binary extends Expression
|
||||
{
|
||||
public enum Operator{
|
||||
ADD,
|
||||
SUB,
|
||||
MUL,
|
||||
AND, OR, DIV
|
||||
}
|
||||
public Binary(Expression expr1, Expression expr2, Operator op){
|
||||
super(null, null);
|
||||
}
|
||||
|
@ -1,25 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import com.sun.scenario.effect.Offset;
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
import org.antlr.v4.runtime.tree.TerminalNode;
|
||||
|
||||
/**
|
||||
* Created by Felix_K on 20.09.2017.
|
||||
*/
|
||||
public class BreakStmt extends Statement
|
||||
{
|
||||
public final String indentifier;
|
||||
|
||||
public BreakStmt(RefTypeOrTPHOrWildcardOrGeneric type, String Indentifier, Token offset)
|
||||
{
|
||||
super(type, offset);
|
||||
this.indentifier=Indentifier;
|
||||
}
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
@ -1,15 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Created by Felix_K on 21.09.2017.
|
||||
*/
|
||||
public class CatchesStatement
|
||||
{
|
||||
final List<Statement> catchClauses;
|
||||
public CatchesStatement(List<Statement> catches)
|
||||
{
|
||||
catchClauses = catches;
|
||||
}
|
||||
}
|
@ -1,14 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
/**
|
||||
* Created by Felix_K on 22.09.2017.
|
||||
*/
|
||||
public class ContinueStmt extends BreakStmt {
|
||||
public ContinueStmt(RefTypeOrTPHOrWildcardOrGeneric type, String indent, Token offset){
|
||||
super(type, indent, offset);
|
||||
}
|
||||
}
|
@ -1,18 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public class DoStmt extends WhileStmt
|
||||
{
|
||||
public DoStmt(Expression expr, Statement loopBlock, Token offset)
|
||||
{
|
||||
super(expr, loopBlock, offset);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
@ -1,7 +1,6 @@
|
||||
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
@ -9,9 +8,19 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public abstract class Expression extends TypableStatement
|
||||
public abstract class Expression extends SyntaxTreeNode
|
||||
{
|
||||
private RefTypeOrTPHOrWildcardOrGeneric type;
|
||||
|
||||
public Expression(RefTypeOrTPHOrWildcardOrGeneric type, Token offset){
|
||||
super(type, offset);
|
||||
super(offset);
|
||||
if(type == null)throw new NullPointerException();
|
||||
this.type = type;
|
||||
}
|
||||
|
||||
public RefTypeOrTPHOrWildcardOrGeneric getType(){
|
||||
return type;
|
||||
}
|
||||
|
||||
public abstract void accept(StatementVisitor visitor);
|
||||
}
|
||||
|
@ -1,28 +1,22 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
|
||||
public class IfStmt extends Statement
|
||||
{
|
||||
public final Expression expr;
|
||||
public final Statement then_block;
|
||||
public final Statement else_block;
|
||||
|
||||
public IfStmt(RefTypeOrTPHOrWildcardOrGeneric type,
|
||||
Expression expr, Statement thenBlock, Statement elseBlock, Token offset)
|
||||
public IfStmt(int offset, int variableLength)
|
||||
{
|
||||
super(type,offset);
|
||||
this.expr = expr;
|
||||
this.then_block = thenBlock;
|
||||
this.else_block = elseBlock;
|
||||
super(null,null);
|
||||
}
|
||||
|
||||
|
||||
public boolean hamaDebug = true; //hama: Debug Ausgaben von mir ein- bzw. ausschalten
|
||||
public Expression expr;
|
||||
public Block then_block;
|
||||
public Block else_block;
|
||||
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
|
24
src/de/dhbwstuttgart/syntaxtree/statement/InstVar.java
Executable file
24
src/de/dhbwstuttgart/syntaxtree/statement/InstVar.java
Executable file
@ -0,0 +1,24 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
|
||||
public class InstVar extends Expression
|
||||
{
|
||||
private Expression expr;
|
||||
public InstVar(Expression instanz, String name, Token offset)
|
||||
{
|
||||
super(instanz.getType(),offset);
|
||||
expr = instanz;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
@ -8,7 +8,7 @@ import de.dhbwstuttgart.typeinference.constraints.Constraint;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Pair;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
//import sun.reflect.generics.reflectiveObjects.NotImplementedException;
|
||||
import sun.reflect.generics.reflectiveObjects.NotImplementedException;
|
||||
|
||||
import java.util.ArrayList;
|
||||
|
||||
|
@ -0,0 +1,17 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.FormalParameter;
|
||||
|
||||
/**
|
||||
* Der FormalParameter einer LambdaExpression hat gesonderte Eigenschaften.
|
||||
* @author janulrich
|
||||
*
|
||||
*/
|
||||
public class LambdaParameter extends FormalParameter {
|
||||
|
||||
public LambdaParameter(FormalParameter fp) {
|
||||
super(null,null,null);
|
||||
}
|
||||
|
||||
|
||||
}
|
@ -1,23 +1,28 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public class LocalVar extends Statement{
|
||||
|
||||
public final String name;
|
||||
protected final String expression;
|
||||
|
||||
public LocalVar(String n, RefTypeOrTPHOrWildcardOrGeneric type, Token offset)
|
||||
{
|
||||
super(type,offset);
|
||||
this.name = n;
|
||||
this.expression = n;
|
||||
}
|
||||
|
||||
public LocalVar(Expression e1, RefTypeOrTPHOrWildcardOrGeneric type, String access)
|
||||
{
|
||||
super(type,e1.getOffset());
|
||||
this.name = access;
|
||||
this.expression = access;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -31,7 +31,7 @@ public class NewClass extends MethodCall
|
||||
* @param start
|
||||
*/
|
||||
public NewClass(RefType newClass, ArgumentList args, Token start) {
|
||||
super(newClass, new Receiver(new EmptyStmt(start)), newClass.getName().toString(), args, start);
|
||||
super(newClass, new Receiver(new EmptyStmt(start)), "new "+newClass.getName().toString(), args, start);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -3,7 +3,6 @@ import java.util.Hashtable;
|
||||
import java.util.Iterator;
|
||||
|
||||
import de.dhbwstuttgart.parser.antlr.Java8Parser;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
import org.apache.bcel.generic.ClassGen;
|
||||
import org.apache.bcel.generic.InstructionList;
|
||||
|
||||
|
@ -4,15 +4,12 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
|
||||
public class PostIncExpr extends UnaryExpr
|
||||
{
|
||||
final Expression expr;
|
||||
public PostIncExpr(Expression expr) {
|
||||
super(null);
|
||||
this.expr=expr;
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -12,10 +12,8 @@ import org.apache.bcel.generic.InstructionList;
|
||||
|
||||
public class PreDecExpr extends UnaryExpr
|
||||
{
|
||||
Expression expr;
|
||||
public PreDecExpr(Expression expr, Token offset)
|
||||
public PreDecExpr(Token offset)
|
||||
{
|
||||
super(offset);
|
||||
this.expr=expr;
|
||||
}
|
||||
}
|
||||
|
@ -5,10 +5,8 @@ import org.antlr.v4.runtime.Token;
|
||||
|
||||
public class PreIncExpr extends UnaryExpr
|
||||
{
|
||||
final Expression expr;
|
||||
public PreIncExpr(Expression expr,Token offset)
|
||||
public PreIncExpr(Token offset)
|
||||
{
|
||||
super(offset);
|
||||
this.expr=expr;
|
||||
}
|
||||
}
|
||||
|
@ -1,9 +1,5 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.Void;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
import org.apache.bcel.Constants;
|
||||
import org.apache.bcel.generic.InstructionFactory;
|
||||
import org.apache.bcel.generic.InstructionHandle;
|
||||
@ -11,22 +7,18 @@ import org.apache.bcel.generic.InstructionList;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
|
||||
|
||||
import java.util.ArrayList;
|
||||
|
||||
|
||||
public class SuperCall extends MethodCall
|
||||
public class SuperCall extends ThisCall
|
||||
{
|
||||
public SuperCall(Token offset){
|
||||
this(new ArgumentList(new ArrayList<Expression>(), offset),offset);
|
||||
public SuperCall(int offset,int variableLength)
|
||||
{
|
||||
super(null,null,variableLength);
|
||||
}
|
||||
|
||||
public SuperCall(ArgumentList argumentList, Token offset){
|
||||
super(new Void(offset), new Receiver(new This(offset)), "<init>", argumentList, offset);
|
||||
public SuperCall(SyntaxTreeNode parent){
|
||||
this(0,0);
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -1,24 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
/**
|
||||
* Created by Felix_K on 23.09.2017.
|
||||
*/
|
||||
public class SwitchStmt extends Statement
|
||||
{
|
||||
public final Expression expr;
|
||||
public final Block switchBlock;
|
||||
|
||||
public SwitchStmt(RefTypeOrTPHOrWildcardOrGeneric type,Expression expr, Block block, Token offset){
|
||||
super(type,offset);
|
||||
this.expr=expr;
|
||||
this.switchBlock=block;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
}
|
||||
}
|
@ -1,6 +1,7 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.operator.Operator;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
|
||||
|
@ -1,28 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public abstract class TypableStatement extends SyntaxTreeNode{
|
||||
private RefTypeOrTPHOrWildcardOrGeneric type;
|
||||
|
||||
public TypableStatement(RefTypeOrTPHOrWildcardOrGeneric type, Token offset){
|
||||
super(offset);
|
||||
if(type == null)throw new NullPointerException();
|
||||
this.type = type;
|
||||
}
|
||||
|
||||
public RefTypeOrTPHOrWildcardOrGeneric getType(){
|
||||
return type;
|
||||
}
|
||||
|
||||
public abstract void accept(StatementVisitor visitor);
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
this.accept((StatementVisitor)visitor);
|
||||
}
|
||||
}
|
@ -2,23 +2,28 @@ package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public class WhileStmt extends Statement
|
||||
{
|
||||
public final Expression expr;
|
||||
public final Statement loopBlock;
|
||||
|
||||
public WhileStmt(Expression expr, Statement loopBlock, Token offset)
|
||||
public WhileStmt(int offset, int variableLength)
|
||||
{
|
||||
super(TypePlaceholder.fresh(offset), offset);
|
||||
this.expr = expr;
|
||||
this.loopBlock = loopBlock;
|
||||
super(null,null);
|
||||
}
|
||||
|
||||
public Expression expr;
|
||||
public Block loop_block;
|
||||
|
||||
/**
|
||||
* <br/>Author: Martin Pl�micke
|
||||
* @return
|
||||
*/
|
||||
public String toString()
|
||||
{
|
||||
return "WHILE " + loop_block.toString();
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -1,8 +1,6 @@
|
||||
package de.dhbwstuttgart.syntaxtree.type;
|
||||
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
/**
|
||||
@ -19,7 +17,7 @@ public class ExtendsWildcardType extends WildcardType{
|
||||
* Author: Arne Lüdtke<br/>
|
||||
* Standard Konstruktor für eine ExtendsWildcard
|
||||
*/
|
||||
public ExtendsWildcardType (RefTypeOrTPHOrWildcardOrGeneric extendsType, Token offset)
|
||||
public ExtendsWildcardType (RefType extendsType, Token offset)
|
||||
{
|
||||
super(extendsType, offset);
|
||||
}
|
||||
@ -35,13 +33,4 @@ public class ExtendsWildcardType extends WildcardType{
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ResultSetVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
@ -1,9 +1,6 @@
|
||||
package de.dhbwstuttgart.syntaxtree.type;
|
||||
|
||||
|
||||
import de.dhbwstuttgart.parser.NullToken;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassName;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
@ -16,17 +13,22 @@ import java.util.List;
|
||||
*
|
||||
*/
|
||||
public class FunN extends RefType {
|
||||
|
||||
private RefTypeOrTPHOrWildcardOrGeneric R;
|
||||
private List<? extends RefTypeOrTPHOrWildcardOrGeneric> T;
|
||||
|
||||
/**
|
||||
* @author Andreas Stadelmeier, a10023
|
||||
* Benötigt für den Typinferenzalgorithmus für Java 8
|
||||
* Generiert einen RefType auf eine FunN<R,T1,...,TN> - Klasse.
|
||||
* @param params
|
||||
* @param R
|
||||
* @param T
|
||||
* @return
|
||||
*/
|
||||
public FunN(List<RefTypeOrTPHOrWildcardOrGeneric> params) {
|
||||
super(new JavaClassName("Fun"+params.size()), params, new NullToken());
|
||||
public FunN(RefTypeOrTPHOrWildcardOrGeneric R, List<? extends RefTypeOrTPHOrWildcardOrGeneric> T) {
|
||||
super(null,null);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Spezieller Konstruktor um eine FunN ohne Returntype zu generieren
|
||||
|
||||
|
@ -1,9 +1,7 @@
|
||||
package de.dhbwstuttgart.syntaxtree.type;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.typecheck.GenericTypeName;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassName;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric
|
||||
@ -22,15 +20,5 @@ public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric
|
||||
public String getUniqueIdentifier(){
|
||||
return name.toString();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ResultSetVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1,8 +1,6 @@
|
||||
package de.dhbwstuttgart.syntaxtree.type;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassName;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import java.util.ArrayList;
|
||||
@ -102,14 +100,5 @@ public class RefType extends RefTypeOrTPHOrWildcardOrGeneric
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ResultSetVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1,17 +1,10 @@
|
||||
package de.dhbwstuttgart.syntaxtree.type;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public abstract class RefTypeOrTPHOrWildcardOrGeneric extends SyntaxTreeNode{
|
||||
public class RefTypeOrTPHOrWildcardOrGeneric extends SyntaxTreeNode{
|
||||
public RefTypeOrTPHOrWildcardOrGeneric(Token offset) {
|
||||
super(offset);
|
||||
}
|
||||
|
||||
@Override
|
||||
public abstract void accept(ASTVisitor visitor);
|
||||
|
||||
public abstract void accept(ResultSetVisitor visitor);
|
||||
}
|
||||
|
@ -1,8 +1,6 @@
|
||||
package de.dhbwstuttgart.syntaxtree.type;
|
||||
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
/**
|
||||
@ -19,7 +17,7 @@ public class SuperWildcardType extends WildcardType{
|
||||
* Author: Arne Lüdtke<br/>
|
||||
* Standard Konstruktor für eine SuperWildcard
|
||||
*/
|
||||
public SuperWildcardType( RefTypeOrTPHOrWildcardOrGeneric innerType, Token offset)
|
||||
public SuperWildcardType( RefType innerType, Token offset)
|
||||
{
|
||||
super(innerType, offset);
|
||||
}
|
||||
@ -44,14 +42,4 @@ public class SuperWildcardType extends WildcardType{
|
||||
public boolean isSuper() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ResultSetVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
@ -1,10 +1,8 @@
|
||||
package de.dhbwstuttgart.syntaxtree.type;
|
||||
import java.util.Hashtable;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
|
||||
import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
/**
|
||||
@ -67,14 +65,4 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ResultSetVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
@ -11,19 +11,19 @@ import org.antlr.v4.runtime.Token;
|
||||
|
||||
public abstract class WildcardType extends RefTypeOrTPHOrWildcardOrGeneric {
|
||||
|
||||
protected RefTypeOrTPHOrWildcardOrGeneric innerType = null;
|
||||
protected RefType innerType = null;
|
||||
|
||||
/**
|
||||
* Author: Arne Lüdtke<br/>
|
||||
* Standard Konstruktor für eine Wildcard
|
||||
*/
|
||||
public WildcardType(RefTypeOrTPHOrWildcardOrGeneric innerType, Token offset)
|
||||
public WildcardType(RefType innerType, Token offset)
|
||||
{
|
||||
super(offset);
|
||||
this.innerType = innerType;
|
||||
}
|
||||
|
||||
public RefTypeOrTPHOrWildcardOrGeneric getInnerType(){
|
||||
public RefType getInnerType(){
|
||||
return innerType;
|
||||
}
|
||||
|
||||
|
@ -1,13 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree.visual;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
|
||||
public class ASTPrinter {
|
||||
|
||||
public static String print(SourceFile toPrint){
|
||||
StringBuilder output = new StringBuilder();
|
||||
new OutputGenerator(output).visit(toPrint);
|
||||
return output.toString();
|
||||
}
|
||||
|
||||
}
|
@ -1,20 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree.visual;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.util.Iterator;
|
||||
|
||||
public class ASTTypePrinter extends ASTPrinter{
|
||||
|
||||
public static String print(SourceFile toPrint){
|
||||
StringBuilder output = new StringBuilder();
|
||||
new TypeOutputGenerator(output).visit(toPrint);
|
||||
return output.toString();
|
||||
}
|
||||
|
||||
}
|
@ -1,366 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree.visual;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.util.Iterator;
|
||||
|
||||
public class OutputGenerator implements ASTVisitor {
|
||||
private static final String TAB = " ";
|
||||
String tabs = "";
|
||||
protected final StringBuilder out;
|
||||
|
||||
public OutputGenerator(StringBuilder out){
|
||||
this.out = out;
|
||||
}
|
||||
|
||||
public void tab() {
|
||||
tabs += TAB;
|
||||
}
|
||||
|
||||
public void untab() {
|
||||
tabs = tabs.substring(0,tabs.length()-TAB.length());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SourceFile sourceFile) {
|
||||
for(ClassOrInterface cl : sourceFile.getClasses()){
|
||||
cl.accept(this);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ArgumentList argumentList) {
|
||||
out.append("(");
|
||||
Iterator<Expression> expressionIterator = argumentList.getArguments().iterator();
|
||||
while(expressionIterator.hasNext()){
|
||||
expressionIterator.next().accept(this);
|
||||
if(expressionIterator.hasNext())out.append(", ");
|
||||
}
|
||||
out.append(")");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(GenericTypeVar genericTypeVar) {
|
||||
out.append(genericTypeVar.getName().toString());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(FormalParameter formalParameter) {
|
||||
formalParameter.getType().accept(this);
|
||||
out.append(" ");
|
||||
out.append(formalParameter.getName());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(GenericDeclarationList genericTypeVars) {
|
||||
Iterator<GenericTypeVar> genericIterator = genericTypeVars.iterator();
|
||||
if(genericIterator.hasNext()){
|
||||
out.append("<");
|
||||
while(genericIterator.hasNext()){
|
||||
genericIterator.next().accept(this);
|
||||
if(genericIterator.hasNext())out.append(", ");
|
||||
}
|
||||
out.append(">");
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Field field) {
|
||||
field.getType().accept(this);
|
||||
out.append(" ");
|
||||
out.append(field.getName());
|
||||
out.append(";");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Method method) {
|
||||
method.getType().accept(this);
|
||||
out.append(" " + method.getName());
|
||||
method.getParameterList().accept(this);
|
||||
if(method.block != null)
|
||||
method.block.accept(this);
|
||||
out.append("\n");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Constructor method) {
|
||||
out.append(method.getName());
|
||||
method.getParameterList().accept(this);
|
||||
method.block.accept(this);
|
||||
out.append("\n");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ParameterList formalParameters) {
|
||||
out.append("(");
|
||||
Iterator<FormalParameter> genericIterator = formalParameters.getFormalparalist().iterator();
|
||||
if(genericIterator.hasNext()){
|
||||
while(genericIterator.hasNext()){
|
||||
genericIterator.next().accept(this);
|
||||
if(genericIterator.hasNext())out.append(", ");
|
||||
}
|
||||
}
|
||||
out.append(")");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ClassOrInterface classOrInterface) {
|
||||
if((Modifier.INTERFACE & classOrInterface.getModifiers()) == 1){
|
||||
out.append("interface ");
|
||||
}else{
|
||||
out.append("class ");
|
||||
}
|
||||
out.append(classOrInterface.getClassName().toString());
|
||||
classOrInterface.getGenerics().accept(this);
|
||||
out.append(" {\n\n");
|
||||
tab();
|
||||
for(Field f : classOrInterface.getFieldDecl()){
|
||||
out.append(tabs);
|
||||
f.accept(this);
|
||||
out.append("\n");
|
||||
}
|
||||
for(Method m : classOrInterface.getMethods()){
|
||||
out.append(tabs);
|
||||
m.accept(this);
|
||||
out.append("\n");
|
||||
}
|
||||
for(Constructor m : classOrInterface.getConstructors()){
|
||||
out.append(tabs);
|
||||
m.accept(this);
|
||||
out.append("\n");
|
||||
}
|
||||
untab();
|
||||
out.append("}");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(RefType refType) {
|
||||
out.append(refType.getName().toString());
|
||||
Iterator<RefTypeOrTPHOrWildcardOrGeneric> genericIterator = refType.getParaList().iterator();
|
||||
if(genericIterator.hasNext()){
|
||||
out.append("<");
|
||||
while(genericIterator.hasNext()){
|
||||
genericIterator.next().accept(this);
|
||||
if(genericIterator.hasNext())out.append(", ");
|
||||
}
|
||||
out.append(">");
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SuperWildcardType superWildcardType) {
|
||||
out.append("? super ");
|
||||
superWildcardType.getInnerType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(TypePlaceholder typePlaceholder) {
|
||||
out.append("TPH "+ typePlaceholder.getName());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ExtendsWildcardType extendsWildcardType) {
|
||||
out.append("? extends ");
|
||||
extendsWildcardType.getInnerType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(GenericRefType genericRefType) {
|
||||
out.append(genericRefType.getName().toString());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(LambdaExpression lambdaExpression) {
|
||||
lambdaExpression.params.accept(this);
|
||||
out.append(" -> ");
|
||||
lambdaExpression.methodBody.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Assign assign) {
|
||||
assign.lefSide.accept(this);
|
||||
out.append(" = ");
|
||||
assign.rightSide.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Binary binary) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Block block) {
|
||||
tab();
|
||||
out.append("{\n");
|
||||
for(Statement stmt : block.getStatements()){
|
||||
out.append(tabs);
|
||||
stmt.accept(this);
|
||||
out.append(";\n");
|
||||
}
|
||||
untab();
|
||||
out.append(tabs);
|
||||
out.append("}");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(BreakStmt breakStmt)
|
||||
{
|
||||
out.append("break"+ " " + breakStmt.indentifier);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(CastExpr castExpr) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(EmptyStmt emptyStmt) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(FieldVar fieldVar) {
|
||||
fieldVar.receiver.accept(this);
|
||||
out.append("." + fieldVar.fieldVarName);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ForStmt forStmt) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(IfStmt ifStmt) {
|
||||
out.append("if (");
|
||||
ifStmt.expr.accept(this);
|
||||
out.append(")");
|
||||
//TODO implement to set ; if then block is empty
|
||||
ifStmt.then_block.accept(this);
|
||||
out.append("else");
|
||||
ifStmt.else_block.accept(this);
|
||||
|
||||
//TODO Felix_K
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(InstanceOf instanceOf) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(LocalVar localVar) {
|
||||
out.append(localVar.name);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(LocalVarDecl localVarDecl) {
|
||||
localVarDecl.getType().accept(this);
|
||||
out.append(" " + localVarDecl.getName());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(MethodCall methodCall) {
|
||||
methodCall.receiver.accept(this);
|
||||
out.append("."+methodCall.name);
|
||||
methodCall.getArgumentList().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(NewClass methodCall) {
|
||||
out.append("new ");
|
||||
out.append(methodCall.name);
|
||||
methodCall.getArgumentList().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(NewArray newArray) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Receiver receiver) {
|
||||
receiver.expr.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Return aReturn) {
|
||||
out.append("return ");
|
||||
aReturn.retexpr.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ReturnVoid aReturn) {
|
||||
out.append("return");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(StaticClassName staticClassName) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Super aSuper) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(This aThis) {
|
||||
out.append("this");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(UnaryPlus unaryPlus) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(WhileStmt whileStmt) {
|
||||
out.append("while(");
|
||||
whileStmt.expr.accept(this);
|
||||
out.append(")");
|
||||
whileStmt.loopBlock.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(DoStmt whileStmt) {
|
||||
out.append("do ");
|
||||
whileStmt.loopBlock.accept(this);
|
||||
out.append("while(");
|
||||
whileStmt.expr.accept(this);
|
||||
out.append(");");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Null aNull) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Literal literal) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(AssignToField assignLeftSide) {
|
||||
assignLeftSide.field.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(AssignToLocal assignLeftSide) {
|
||||
assignLeftSide.localVar.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SuperCall superCall) {
|
||||
out.append("super(");
|
||||
superCall.arglist.accept(this);
|
||||
out.append(")");
|
||||
}
|
||||
}
|
@ -1,236 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree.visual;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.util.Iterator;
|
||||
|
||||
public class TypeOutputGenerator extends OutputGenerator {
|
||||
|
||||
TypeOutputGenerator(StringBuilder out){
|
||||
super(out);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SourceFile sourceFile) {
|
||||
super.visit(sourceFile);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ArgumentList argumentList) {
|
||||
super.visit(argumentList);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(GenericTypeVar genericTypeVar) {
|
||||
super.visit(genericTypeVar);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(FormalParameter formalParameter) {
|
||||
super.visit(formalParameter);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(GenericDeclarationList genericTypeVars) {
|
||||
super.visit(genericTypeVars);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Field field) {
|
||||
super.visit(field);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Method method) {
|
||||
super.visit(method);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ParameterList formalParameters) {
|
||||
super.visit(formalParameters);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ClassOrInterface classOrInterface) {
|
||||
super.visit(classOrInterface);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(RefType refType) {
|
||||
super.visit(refType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SuperWildcardType superWildcardType) {
|
||||
super.visit(superWildcardType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(TypePlaceholder typePlaceholder) {
|
||||
super.visit(typePlaceholder);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ExtendsWildcardType extendsWildcardType) {
|
||||
super.visit(extendsWildcardType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(GenericRefType genericRefType) {
|
||||
super.visit(genericRefType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(LambdaExpression lambdaExpression) {
|
||||
out.append("(");
|
||||
super.visit(lambdaExpression);
|
||||
out.append(")");
|
||||
this.out.append("::");
|
||||
lambdaExpression.getType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Assign assign) {
|
||||
super.visit(assign);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Binary binary) {
|
||||
super.visit(binary);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Block block) {
|
||||
out.append("(");
|
||||
super.visit(block);
|
||||
out.append(")");
|
||||
this.out.append("::");
|
||||
block.getType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(CastExpr castExpr) {
|
||||
super.visit(castExpr);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(EmptyStmt emptyStmt) {
|
||||
super.visit(emptyStmt);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(FieldVar fieldVar) {
|
||||
out.append("(");
|
||||
super.visit(fieldVar);
|
||||
out.append(")");
|
||||
this.out.append("::");
|
||||
fieldVar.getType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ForStmt forStmt) {
|
||||
super.visit(forStmt);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(IfStmt ifStmt) {
|
||||
super.visit(ifStmt);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(InstanceOf instanceOf) {
|
||||
super.visit(instanceOf);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(LocalVar localVar) {
|
||||
out.append("(");
|
||||
super.visit(localVar);
|
||||
out.append(")");
|
||||
this.out.append("::");
|
||||
localVar.getType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(LocalVarDecl localVarDecl) {
|
||||
super.visit(localVarDecl);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(MethodCall methodCall) {
|
||||
out.append("(");
|
||||
super.visit(methodCall);
|
||||
out.append(")");
|
||||
this.out.append("::");
|
||||
methodCall.getType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(NewClass methodCall) {
|
||||
super.visit(methodCall);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(NewArray newArray) {
|
||||
super.visit(newArray);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Receiver receiver) {
|
||||
super.visit(receiver);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Return aReturn) {
|
||||
super.visit(aReturn);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ReturnVoid aReturn) {
|
||||
super.visit(aReturn);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(StaticClassName staticClassName) {
|
||||
super.visit(staticClassName);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Super aSuper) {
|
||||
super.visit(aSuper);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(This aThis) {
|
||||
out.append("(");
|
||||
super.visit(aThis);
|
||||
out.append(")");
|
||||
this.out.append("::");
|
||||
aThis.getType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(UnaryPlus unaryPlus) {
|
||||
super.visit(unaryPlus);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(WhileStmt whileStmt) {
|
||||
super.visit(whileStmt);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Null aNull) {
|
||||
super.visit(aNull);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Literal literal) {
|
||||
super.visit(literal);
|
||||
}
|
||||
}
|
@ -1,7 +1,7 @@
|
||||
package de.dhbwstuttgart.typecheck;
|
||||
|
||||
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.GenericContext;
|
||||
//import jdk.nashorn.internal.ir.Node;
|
||||
import jdk.nashorn.internal.ir.Node;
|
||||
|
||||
public class GenericTypeName extends JavaClassName {
|
||||
private final static String DELIMITER = "%";
|
||||
@ -15,9 +15,13 @@ public class GenericTypeName extends JavaClassName {
|
||||
this.methodName = genericContext.parentMethod;
|
||||
}
|
||||
|
||||
public String getUniqueIdentifier() {
|
||||
public String toString(){
|
||||
return parentClass.toString()
|
||||
+ DELIMITER + methodName
|
||||
+ DELIMITER + super.toString();
|
||||
}
|
||||
|
||||
public String getShortName() {
|
||||
return super.toString();
|
||||
}
|
||||
}
|
||||
|
@ -34,15 +34,6 @@ public class JavaClassName {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gibt von einem Klassennamen nur den Namen der Klasse zur<75>ck
|
||||
* Beispiel:
|
||||
* java.lang.Object wird zu: Object
|
||||
*/
|
||||
public static String stripClassName(String className) {
|
||||
return new JavaClassName(className).name;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
final int prime = 31;
|
||||
|
@ -1,13 +1,13 @@
|
||||
package de.dhbwstuttgart.typecheck;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Speichert die Klassen im aktuellen Projektscope
|
||||
*/
|
||||
public class JavaClassRegistry {
|
||||
final List<JavaClassName> existingClasses = new ArrayList<>();
|
||||
final List<String> importedPackages = new ArrayList<>();
|
||||
public List<JavaClassName> existingClasses = new ArrayList<>();
|
||||
|
||||
public JavaClassRegistry(List<String> initialNames){
|
||||
for(String name : initialNames){
|
||||
@ -15,15 +15,6 @@ public class JavaClassRegistry {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* F<>gt ein gesamtes Package der ClassRegistry hinzu.
|
||||
* Dies geschieht beispielsweise, wenn der Benutzer ein "import package.*;" statement verwendet
|
||||
* @param packageName
|
||||
*/
|
||||
public void addPackage(String packageName) {
|
||||
importedPackages.add(packageName);
|
||||
}
|
||||
|
||||
public void add(String className){
|
||||
existingClasses.add(new JavaClassName(className));
|
||||
}
|
||||
@ -32,13 +23,7 @@ public class JavaClassRegistry {
|
||||
for(JavaClassName name : existingClasses){
|
||||
if(name.equals(new JavaClassName(className)))return name;
|
||||
}
|
||||
//Jetzt noch alle importierten Packages durchsuchen:
|
||||
JavaClassName ret = getClassFromImportedPackages(className);
|
||||
if(ret == null){
|
||||
throw new TypeNotPresentException(className, new Throwable());
|
||||
}else{
|
||||
return ret;
|
||||
}
|
||||
throw new TypeNotPresentException(className, new Throwable());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -47,34 +32,6 @@ public class JavaClassRegistry {
|
||||
}
|
||||
|
||||
public boolean contains(String whole) {
|
||||
boolean ret = existingClasses.contains(new JavaClassName(whole));
|
||||
if(ret == false){
|
||||
JavaClassName imported = getClassFromImportedPackages(whole);
|
||||
if(imported != null){
|
||||
existingClasses.add(imported);
|
||||
return true;
|
||||
}else {
|
||||
return false;
|
||||
}
|
||||
}else {
|
||||
return true;
|
||||
}
|
||||
return existingClasses.contains(new JavaClassName(whole));
|
||||
}
|
||||
|
||||
private JavaClassName getClassFromImportedPackages(String className){
|
||||
ClassLoader loader = Thread.currentThread().getContextClassLoader();
|
||||
String shortName = JavaClassName.stripClassName(className);
|
||||
for(String packageName : importedPackages) {
|
||||
try {
|
||||
loader.loadClass(packageName+"."+shortName);
|
||||
//Keine Exception! Die Klasse existiert:
|
||||
JavaClassName ret = new JavaClassName(packageName+"."+shortName);
|
||||
if(ret.equals(new JavaClassName(className)))return ret;
|
||||
} catch (ClassNotFoundException e) {
|
||||
//Die Klasse wurde nicht gefunden!
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -1,36 +0,0 @@
|
||||
package de.dhbwstuttgart.typedeployment;
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
public class TypeInsert {
|
||||
/**
|
||||
* point wird hauptsächlich zur Anzeige einer Annotation im Eclipse-plugin benutzt.
|
||||
*/
|
||||
public final TypeInsertPoint point;
|
||||
Set<TypeInsertPoint> inserts;
|
||||
|
||||
public TypeInsert(TypeInsertPoint point, Set<TypeInsertPoint> additionalPoints){
|
||||
this.point = point;
|
||||
inserts = additionalPoints;
|
||||
}
|
||||
|
||||
public String insert(String intoSource){
|
||||
List<TypeInsertPoint> offsets = new ArrayList<>();
|
||||
String ret = point.insert(intoSource, offsets);
|
||||
offsets.add(point);
|
||||
for(TypeInsertPoint insertPoint : inserts){
|
||||
ret = insertPoint.insert(ret, offsets);
|
||||
offsets.add(insertPoint);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
public String getInsertString(){
|
||||
return point.getInsertString();
|
||||
}
|
||||
}
|
@ -1,142 +1,54 @@
|
||||
package de.dhbwstuttgart.typedeployment;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
import de.dhbwstuttgart.typeinference.result.*;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.typeinference.ResultSet;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* TODO:
|
||||
* Falls in Feldern Generics entstehen, dann werden diese als Klassenparameter eingesetzt
|
||||
* Für die Instanzierung von Klassen kann man dann beispielsweise nur noch den Diamond-Operator verwenden
|
||||
*
|
||||
* Es müssen zu einem TPH alle in Beziehung stehenden Constraints gefunden werden
|
||||
*
|
||||
* Anmekung: Es wird nur ein RefType gleichzeitug eingesetzt.
|
||||
* Steht dieser mit anderen Typen in Verbindung, so müssen diese nicht eingesetzt werden
|
||||
* im Result set können nur TPHs mit <. Beziehung stehen
|
||||
* Steht ein Typ A über TPHs mit anderen Typen B in Verbindung, so lassen sich diese auch im nächsten Durchgang
|
||||
* inferieren, wenn A bereits eingesetzt wurde. Es werden dann eben zusätzliche Generics entstehen
|
||||
*/
|
||||
public class TypeInsertFactory {
|
||||
public static List<TypeInsertPoint> createTypeInsertPoints(SourceFile forSourcefile, ResultSet withResults){
|
||||
List<TypeInsertPoint> ret = new ArrayList<>();
|
||||
for(ClassOrInterface cl : forSourcefile.getClasses()){
|
||||
//Felder:
|
||||
for(Field field : cl.getFieldDecl()){
|
||||
if(field.getType() instanceof TypePlaceholder){
|
||||
RefTypeOrTPHOrWildcardOrGeneric resolved = withResults.resolveType(field.getType());
|
||||
String toInsert = getString(resolved) + " ";
|
||||
ret.add(new TypeInsertPoint(field.getType().getOffset(), toInsert));
|
||||
}
|
||||
}
|
||||
|
||||
for(Method m : cl.getMethods()){
|
||||
RefTypeOrTPHOrWildcardOrGeneric resolved = withResults.resolveType(m.getReturnType());
|
||||
String toInsert = getString(resolved) + " ";
|
||||
ret.add(new TypeInsertPoint(m.getReturnType().getOffset(), toInsert));
|
||||
|
||||
public static Set<TypeInsert> createTypeInsertPoints(SourceFile forSourcefile, ResultSet withResults){
|
||||
return new TypeInsertPlacer().getTypeInserts(forSourcefile, withResults);
|
||||
for(FormalParameter param : m.getParameterList().getFormalparalist()){
|
||||
resolved = withResults.resolveType(param.getType());
|
||||
toInsert = getString(resolved) + " ";
|
||||
ret.add(new TypeInsertPoint(param.getType().getOffset(), toInsert));
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
public static TypeInsert createInsertPoints(RefTypeOrTPHOrWildcardOrGeneric type, Token offset, ClassOrInterface cl, Method m,
|
||||
ResultSet resultSet) {
|
||||
Set<TypeInsertPoint> ret = new HashSet<>();
|
||||
ResolvedType resolvedType = resultSet.resolveType(type);
|
||||
TypeInsertPoint insertPoint = new TypeInsertPoint(offset,
|
||||
new TypeToInsertString(resolvedType.resolvedType).insert);
|
||||
return new TypeInsert(insertPoint, new HashSet<>(Arrays.asList(createGenericInsert(resolvedType.additionalGenerics, cl, m))));
|
||||
}
|
||||
|
||||
private static TypeInsertPoint createGenericInsert(Set<GenericInsertPair> toInsert, ClassOrInterface cl, Method m){
|
||||
//Momentan wird Methode ignoriert. Parameter werden immer als Klassenparameter angefügt:
|
||||
//Offset zum Einstzen bestimmen:
|
||||
Token offset;
|
||||
String insert = "";
|
||||
String end;
|
||||
if(cl.getGenerics().iterator().hasNext()){
|
||||
//offset = cl.getGenerics().iterator().next().getOffset();
|
||||
offset = cl.getGenerics().getOffset();
|
||||
end=",";
|
||||
private static String getString(RefTypeOrTPHOrWildcardOrGeneric resolved) {
|
||||
if(resolved instanceof RefType){
|
||||
return ((RefType) resolved).getName().toString();
|
||||
}else if(resolved instanceof TypePlaceholder){
|
||||
return ((TypePlaceholder) resolved).getName();
|
||||
}else if(resolved instanceof GenericRefType){
|
||||
return ((GenericRefType)resolved).getName().getShortName().toString();
|
||||
}else{
|
||||
offset = cl.getGenerics().getOffset();
|
||||
insert += "<";
|
||||
end = ">";
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
//Alle einzusetzenden Generics und deren Bounds bestimmen:
|
||||
HashMap<TypePlaceholder, HashSet<TypePlaceholder>> genericsAndBounds = new HashMap<>();
|
||||
for(GenericInsertPair p : toInsert){
|
||||
if(!genericsAndBounds.containsKey(p.TA1)){
|
||||
genericsAndBounds.put((TypePlaceholder) p.TA1, new HashSet<>());
|
||||
}
|
||||
if(p.TA2 != null){
|
||||
genericsAndBounds.get(p.TA1).add((TypePlaceholder) p.TA2);
|
||||
if(!genericsAndBounds.containsKey(p.TA2)){
|
||||
genericsAndBounds.put((TypePlaceholder) p.TA2, new HashSet<>());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//String zum Einsetzen (Generics mit bounds) generieren:
|
||||
Iterator<TypePlaceholder> it = genericsAndBounds.keySet().iterator();
|
||||
if(! it.hasNext())return new TypeInsertPoint(offset, "");
|
||||
while(it.hasNext()){
|
||||
TypePlaceholder tph = it.next();
|
||||
insert += tph.getName();
|
||||
Set<TypePlaceholder> bounds = genericsAndBounds.get(tph);
|
||||
if(bounds.size() > 0){
|
||||
insert += " extends ";
|
||||
Iterator<TypePlaceholder> boundIt = bounds.iterator();
|
||||
while(boundIt.hasNext()){
|
||||
TypePlaceholder bound = boundIt.next();
|
||||
insert += bound.getName();
|
||||
if(boundIt.hasNext())insert += " & ";
|
||||
}
|
||||
}
|
||||
if(it.hasNext())insert+=",";
|
||||
}
|
||||
return new TypeInsertPoint(offset, insert + end);
|
||||
}
|
||||
}
|
||||
|
||||
class TypeToInsertString implements ResultSetVisitor{
|
||||
String insert = "";
|
||||
|
||||
TypeToInsertString(RefTypeOrTPHOrWildcardOrGeneric type){
|
||||
type.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(PairTPHsmallerTPH p) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(PairTPHequalRefType p) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(RefType resolved) {
|
||||
insert = resolved.getName().toString();
|
||||
if(resolved.getParaList().size() > 0){
|
||||
insert += "<";
|
||||
Iterator<RefTypeOrTPHOrWildcardOrGeneric> iterator = resolved.getParaList().iterator();
|
||||
while(iterator.hasNext()){
|
||||
RefTypeOrTPHOrWildcardOrGeneric typeParam = iterator.next();
|
||||
insert += new TypeToInsertString(typeParam).insert;
|
||||
if(iterator.hasNext())insert += ", ";
|
||||
}
|
||||
insert += ">";
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(GenericRefType genericRefType) {
|
||||
insert += genericRefType.getName();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SuperWildcardType superWildcardType) {
|
||||
insert += "? super " + new TypeToInsertString(superWildcardType.getInnerType()).insert;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(TypePlaceholder typePlaceholder) {
|
||||
insert += typePlaceholder.getName();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ExtendsWildcardType extendsWildcardType) {
|
||||
insert += "? extends " + new TypeToInsertString(extendsWildcardType.getInnerType()).insert;
|
||||
}
|
||||
}
|
@ -1,76 +0,0 @@
|
||||
package de.dhbwstuttgart.typedeployment;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.BreakStmt;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSet;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
public class TypeInsertPlacer extends AbstractASTWalker{
|
||||
Set<TypeInsert> inserts = new HashSet<>();
|
||||
private ResultSet withResults;
|
||||
|
||||
public Set<TypeInsert> getTypeInserts(SourceFile forSourceFile, ResultSet withResults){
|
||||
this.withResults = withResults;
|
||||
forSourceFile.accept(this);
|
||||
return inserts;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ClassOrInterface classOrInterface) {
|
||||
TypeInsertPlacerClass cl = new TypeInsertPlacerClass(classOrInterface, withResults);
|
||||
this.inserts.addAll(cl.inserts);
|
||||
}
|
||||
}
|
||||
|
||||
class TypeInsertPlacerClass extends AbstractASTWalker{
|
||||
protected final ResultSet results;
|
||||
protected final ClassOrInterface cl;
|
||||
public final Set<TypeInsert> inserts = new HashSet<>();
|
||||
private Method method;
|
||||
|
||||
TypeInsertPlacerClass(ClassOrInterface forClass, ResultSet withResults){
|
||||
this.cl = forClass;
|
||||
this.method = null;
|
||||
this.results = withResults;
|
||||
forClass.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Method method) {
|
||||
this.method = method;
|
||||
if(method.getReturnType() instanceof TypePlaceholder)
|
||||
inserts.add(TypeInsertFactory.createInsertPoints(
|
||||
method.getReturnType(), method.getReturnType().getOffset(), cl, method, results));
|
||||
super.visit(method);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Field field) {
|
||||
if(field.getType() instanceof TypePlaceholder){
|
||||
inserts.add(TypeInsertFactory.createInsertPoints(
|
||||
field.getType(), field.getType().getOffset(), cl, method, results));
|
||||
}
|
||||
super.visit(field);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ParameterList params) {
|
||||
for(FormalParameter param : params){
|
||||
if(param.getType() instanceof TypePlaceholder)
|
||||
inserts.add(TypeInsertFactory.createInsertPoints(
|
||||
param.getType(), param.getType().getOffset(), cl, method, results));
|
||||
}
|
||||
super.visit(params);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(LambdaExpression lambdaExpression) {
|
||||
//Lambda-Ausdrücke brauchen keine Typeinsetzungen
|
||||
}
|
||||
|
||||
}
|
@ -2,27 +2,16 @@ package de.dhbwstuttgart.typedeployment;
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class TypeInsertPoint {
|
||||
public final Token point;
|
||||
Token point;
|
||||
private String insertString;
|
||||
|
||||
public TypeInsertPoint(Token point, String toInsert){
|
||||
this.point = point;
|
||||
this.insertString = (toInsert.endsWith(" ")) ? toInsert : toInsert + " " ;
|
||||
this.insertString = toInsert;
|
||||
}
|
||||
|
||||
public String insert(String intoSource, List<TypeInsertPoint> additionalOffset){
|
||||
int offset = additionalOffset.stream().filter((token ->
|
||||
//token.point.getLine() != point.getLine() && token.point.getCharPositionInLine() <= point.getCharPositionInLine()))
|
||||
token.point.getStartIndex() <= point.getStartIndex()))
|
||||
.mapToInt((typeInsertPoint -> typeInsertPoint.insertString.length())).sum();
|
||||
return new StringBuilder(intoSource).insert(point.getStartIndex()+offset, insertString).toString();
|
||||
}
|
||||
|
||||
public String getInsertString() {
|
||||
return insertString;
|
||||
public String insert(String intoSource){
|
||||
return new StringBuilder(intoSource).insert(point.getStartIndex(), insertString).toString();
|
||||
}
|
||||
}
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user