diff --git a/src/de/dhbwstuttgart/core/ConsoleInterface.java b/src/de/dhbwstuttgart/core/ConsoleInterface.java index 1c99aa30..9c6735a6 100755 --- a/src/de/dhbwstuttgart/core/ConsoleInterface.java +++ b/src/de/dhbwstuttgart/core/ConsoleInterface.java @@ -7,6 +7,7 @@ import java.util.*; import de.dhbwstuttgart.logger.Logger; import de.dhbwstuttgart.logger.LoggerConfiguration; +import de.dhbwstuttgart.syntaxtree.SourceFile; import de.dhbwstuttgart.typeinference.Menge; import de.dhbwstuttgart.typeinference.TypeinferenceResultSet; import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException; @@ -34,13 +35,13 @@ public class ConsoleInterface { ///////////////////////// // Parsen: ///////////////////////// - compiler.parse(filenames); + Menge sourceFiles = compiler.parse(filenames); ///////////////////////// // Typrekonstruktion: ///////////////////////// try{ - resultSet = compiler.typeReconstruction(); + resultSet = compiler.typeReconstruction(sourceFiles); }catch(TypeinferenceException texc){ texc.printStackTrace(); fail("Fehler bei Typinferenzalgorithmus. Message: "+texc.getMessage()); diff --git a/src/de/dhbwstuttgart/syntaxtree/FormalParameter.java b/src/de/dhbwstuttgart/syntaxtree/FormalParameter.java index e410bd57..ddb325d7 100755 --- a/src/de/dhbwstuttgart/syntaxtree/FormalParameter.java +++ b/src/de/dhbwstuttgart/syntaxtree/FormalParameter.java @@ -236,7 +236,7 @@ public class FormalParameter extends SyntaxTreeNode implements Typeable, TypeIns public String getDescription() { String ret = ""; if(this.getType() != null && !(this.getType() instanceof TypePlaceholder)){ - ret += this.getType().getName() + " "; + ret += this.getType().getBytecodeSignature(null); } return ret+this.getIdentifier(); } diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java index 060ea12c..f39e6968 100644 --- a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java +++ b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java @@ -4,7 +4,10 @@ import de.dhbwstuttgart.bytecode.ClassGenerator; import de.dhbwstuttgart.syntaxtree.Class; import de.dhbwstuttgart.syntaxtree.Constructor; import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.SourceFile; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.syntaxtree.misc.DeclId; +import de.dhbwstuttgart.syntaxtree.misc.UsedId; import de.dhbwstuttgart.syntaxtree.statement.Block; import de.dhbwstuttgart.syntaxtree.statement.SuperCall; import de.dhbwstuttgart.typeinference.Menge; @@ -45,11 +48,16 @@ public class ASTFactory { return new Constructor(method, superClass); } - public static Class createClass(String className, Class superClass) { + public static Class createClass(String className, String superClass, SourceFile parent) { // TODO bytecode createClass Class generatedClass = new Class(className, 0); - generatedClass.addField(ASTFactory.createEmptyConstructor(superClass)); - generatedClass.parserPostProcessing(superClass); + generatedClass.addField(ASTFactory.createEmptyConstructor(generatedClass)); + + if(superClass != null){ + generatedClass.superclassid = UsedId.createFromQualifiedName(superClass, 0); + } + + generatedClass.parserPostProcessing(parent); return generatedClass; } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/RefType.java b/src/de/dhbwstuttgart/syntaxtree/type/RefType.java index 3fe126b4..9f33148b 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/RefType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/RefType.java @@ -16,6 +16,7 @@ import de.dhbwstuttgart.parser.JavaClassName; import de.dhbwstuttgart.syntaxtree.Class; import de.dhbwstuttgart.syntaxtree.Constructor; import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.SourceFile; import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.syntaxtree.factory.ASTFactory; import de.dhbwstuttgart.syntaxtree.misc.UsedId; @@ -852,8 +853,7 @@ public class RefType extends ObjectType implements IMatchable String combinedType = getCombinedType(cg); if(!combinedType.equals(getName().toString())){ // TODO bytecode statt getParentClass die eigene Class?!?! - Class classObject = ASTFactory.createClass(getName().toString(), ASTFactory.createObjectClass()); - Class generatedClass = ASTFactory.createClass(getCombinedType(cg), classObject); + Class generatedClass = ASTFactory.createClass(getCombinedType(cg), getName().toString(), new SourceFile()); cg.addExtraClass(generatedClass.genByteCode(new TypeinferenceResultSet(generatedClass, new Menge<>(), new ResultSet())).getByteCode()); } @@ -869,7 +869,14 @@ public class RefType extends ObjectType implements IMatchable sb.append(getName().toString().replace(".", "%")); sb.append("%%"); for(Type type: parameter){ - sb.append(((RefType) type).getCombinedType(cg).replace(".", "%")); + if(type instanceof RefType){ + sb.append(((RefType) type).getCombinedType(cg).replace(".", "%")); + }else if(type instanceof TypePlaceholder){ + sb.append(((TypePlaceholder) type).getBytecodeType(cg).toString().replace(".", "%")); + }else{ + sb.append(((TypePlaceholder) type).getBytecodeType(cg).toString().replace(".", "%")); + } + sb.append("%"); } }else{ diff --git a/test/bytecode/BytecodeTest.java b/test/bytecode/BytecodeTest.java index 35b8dc33..92c38e19 100644 --- a/test/bytecode/BytecodeTest.java +++ b/test/bytecode/BytecodeTest.java @@ -39,11 +39,7 @@ public abstract class BytecodeTest extends TestCase{ protected Class getClassToTest(){ Class classToTest = null; try { - File file = new File(rootDirectory); - URL url = file.toURL(); - URL[] urls = new URL[]{url}; - - ClassLoader classLoader = new URLClassLoader(urls); + ClassLoader classLoader = getClassLoader(); classToTest = classLoader.loadClass(testName); @@ -54,4 +50,12 @@ public abstract class BytecodeTest extends TestCase{ return classToTest; } + + protected ClassLoader getClassLoader() throws Exception{ + File file = new File(System.getProperty("user.dir")+"/test/bytecode/types/"); + URL url = file.toURL(); + URL[] urls = new URL[]{url}; + + return new URLClassLoader(urls); + } } diff --git a/test/bytecode/types/ExtendsObjectTest.java b/test/bytecode/types/ExtendsObjectTest.java index 43648fdf..964d52c9 100644 --- a/test/bytecode/types/ExtendsObjectTest.java +++ b/test/bytecode/types/ExtendsObjectTest.java @@ -34,7 +34,11 @@ public class ExtendsObjectTest extends BytecodeTest{ @Test public void testConstruct(){ try{ - Class cls = getClassToTest(); + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + + Object obj = cls.newInstance(); Constructor method = cls.getConstructor(new Class[]{}); method.newInstance(); diff --git a/test/bytecode/types/ExtendsVectorStringTest.java b/test/bytecode/types/ExtendsVectorStringTest.java index 8511499b..efcbc095 100644 --- a/test/bytecode/types/ExtendsVectorStringTest.java +++ b/test/bytecode/types/ExtendsVectorStringTest.java @@ -33,7 +33,11 @@ public class ExtendsVectorStringTest extends BytecodeTest{ @Test public void testConstruct() throws Exception{ - Class cls = getClassToTest(); + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + + Object obj = cls.newInstance(); Constructor method = cls.getConstructor(new Class[]{}); method.newInstance(); diff --git a/test/bytecode/types/ExtendsVectorTest.java b/test/bytecode/types/ExtendsVectorTest.java index aefe5d4b..5253507e 100644 --- a/test/bytecode/types/ExtendsVectorTest.java +++ b/test/bytecode/types/ExtendsVectorTest.java @@ -34,7 +34,11 @@ public class ExtendsVectorTest extends BytecodeTest{ @Test public void testConstruct(){ try{ - Class cls = getClassToTest(); + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + + Object obj = cls.newInstance(); Constructor method = cls.getConstructor(new Class[]{}); method.newInstance(); diff --git a/test/bytecode/types/LocalVariableStringVector.jav b/test/bytecode/types/LocalVariableStringVector.jav new file mode 100644 index 00000000..887c82d6 --- /dev/null +++ b/test/bytecode/types/LocalVariableStringVector.jav @@ -0,0 +1,7 @@ +import java.util.Vector; + +class LocalVariableStringVector{ + void method() { + Vector vector; + } +} \ No newline at end of file diff --git a/test/bytecode/types/LocalVariableStringVectorTest.java b/test/bytecode/types/LocalVariableStringVectorTest.java new file mode 100644 index 00000000..a3761210 --- /dev/null +++ b/test/bytecode/types/LocalVariableStringVectorTest.java @@ -0,0 +1,39 @@ +package bytecode.types; + +import static org.junit.Assert.*; + +import java.io.File; +import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.Vector; + +import org.junit.Test; + +import bytecode.BytecodeTest; + +public class LocalVariableStringVectorTest extends BytecodeTest{ + @Override + protected void init() { + testName = "LocalVariableStringVector"; + rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/"; + } + + + + @Test + public void testCompiler() { + try{ + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + + Object obj = cls.newInstance(); + + assertTrue(true); + }catch(Exception e){ + throw new RuntimeException(e); + } + } + +} diff --git a/test/bytecode/types/LocalVariableVector.jav b/test/bytecode/types/LocalVariableVector.jav new file mode 100644 index 00000000..13cd673c --- /dev/null +++ b/test/bytecode/types/LocalVariableVector.jav @@ -0,0 +1,7 @@ +import java.util.Vector; + +class LocalVariableVector{ + void method() { + Vector vector; + } +} \ No newline at end of file diff --git a/test/bytecode/types/LocalVariableVectorTest.java b/test/bytecode/types/LocalVariableVectorTest.java new file mode 100644 index 00000000..52869f43 --- /dev/null +++ b/test/bytecode/types/LocalVariableVectorTest.java @@ -0,0 +1,38 @@ +package bytecode.types; + +import static org.junit.Assert.*; + +import java.io.File; +import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.Vector; + +import org.junit.Test; + +import bytecode.BytecodeTest; + +public class LocalVariableVectorTest extends BytecodeTest{ + @Override + protected void init() { + testName = "LocalVariableVector"; + rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/"; + } + + + + @Test + public void testCompiler() { + try{ + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + + Object obj = cls.newInstance(); + + assertTrue(true); + }catch(Exception e){ + throw new RuntimeException(e); + } + } +} diff --git a/test/bytecode/types/TypedVector.jav b/test/bytecode/types/MethodWithTypedVector.jav similarity index 70% rename from test/bytecode/types/TypedVector.jav rename to test/bytecode/types/MethodWithTypedVector.jav index d64e4f5f..a74062ee 100644 --- a/test/bytecode/types/TypedVector.jav +++ b/test/bytecode/types/MethodWithTypedVector.jav @@ -1,6 +1,6 @@ import java.util.Vector; -class TypedVector{ +class MethodWithTypedVector{ public void method(Vector v) { } diff --git a/test/bytecode/types/TypedVectorTest.java b/test/bytecode/types/MethodWithTypedVectorTest.java similarity index 55% rename from test/bytecode/types/TypedVectorTest.java rename to test/bytecode/types/MethodWithTypedVectorTest.java index ef32180b..6933c248 100644 --- a/test/bytecode/types/TypedVectorTest.java +++ b/test/bytecode/types/MethodWithTypedVectorTest.java @@ -2,7 +2,10 @@ package bytecode.types; import static org.junit.Assert.*; +import java.io.File; import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; import java.util.Stack; import java.util.Vector; @@ -12,30 +15,31 @@ import bytecode.BytecodeTest; import de.dhbwstuttgart.logger.Logger; import de.dhbwstuttgart.logger.Section; -public class TypedVectorTest extends BytecodeTest{ +public class MethodWithTypedVectorTest extends BytecodeTest{ @Override protected void init() { - testName = "TypedVector"; + testName = "MethodWithTypedVector"; rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/"; } @Test public void test() { try{ - Class cls = getClassToTest(); + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + Object obj = cls.newInstance(); - - Vector stringVector = new Vector(); + + Class stringVector = classLoader.loadClass("java%util%Vector%%java%lang%String%"); Class[] params = new Class[1]; - params[0] = stringVector.getClass(); + params[0] = stringVector; Method method = cls.getDeclaredMethod("method", params); - method.invoke(obj, stringVector); - assertTrue(true); + method.invoke(obj, stringVector.newInstance()); }catch(Exception e){ - Logger.getLogger("SingleClassTester").error(e.toString(), Section.CODEGEN); - fail(); + throw new RuntimeException(e); } } } diff --git a/test/bytecode/types/MethodWithUntypedVector.jav b/test/bytecode/types/MethodWithUntypedVector.jav new file mode 100644 index 00000000..fead3981 --- /dev/null +++ b/test/bytecode/types/MethodWithUntypedVector.jav @@ -0,0 +1,7 @@ +import java.util.Vector; + +class MethodWithUntypedVector{ + public void method(Vector v) { + + } +} \ No newline at end of file diff --git a/test/bytecode/types/MethodWithUntypedVectorTest.java b/test/bytecode/types/MethodWithUntypedVectorTest.java new file mode 100644 index 00000000..1be45ff0 --- /dev/null +++ b/test/bytecode/types/MethodWithUntypedVectorTest.java @@ -0,0 +1,68 @@ +package bytecode.types; + +import static org.junit.Assert.*; + +import java.io.File; +import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.Stack; +import java.util.Vector; + +import org.junit.Test; + +import bytecode.BytecodeTest; +import de.dhbwstuttgart.logger.Logger; +import de.dhbwstuttgart.logger.Section; + +public class MethodWithUntypedVectorTest extends BytecodeTest{ + @Override + protected void init() { + testName = "MethodWithUntypedVector"; + rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/"; + } + + @Test + public void testObjectVector() { + try{ + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + + Object obj = cls.newInstance(); + + File file = new File(rootDirectory); + URL url = file.toURL(); + URL[] urls = new URL[]{url}; + + Object object = new Object(); + + Class[] params = new Class[1]; + params[0] = object.getClass(); + + Method method = cls.getDeclaredMethod("method", params); + method.invoke(obj, object); + }catch(Exception e){ + throw new RuntimeException(e); + } + } + + @Test + public void testGenericClass() { + try{ + ClassLoader classLoader = getClassLoader(); + + Class untypedVectorTest = classLoader.loadClass(testName); + + Class stringVector = classLoader.loadClass("java%util%Vector%%java%lang%Object%"); + + Class[] params = new Class[1]; + params[0] = stringVector; + + Method method = untypedVectorTest.getDeclaredMethod("method", params); + method.invoke(untypedVectorTest.newInstance(), stringVector.newInstance()); + }catch(Exception e){ + throw new RuntimeException(e); + } + } +} diff --git a/test/bytecode/types/OverloadingTest.java b/test/bytecode/types/OverloadingTest.java index f8f6a862..1bc0bed4 100644 --- a/test/bytecode/types/OverloadingTest.java +++ b/test/bytecode/types/OverloadingTest.java @@ -2,7 +2,10 @@ package bytecode.types; import static org.junit.Assert.*; +import java.io.File; import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; import java.util.Vector; import org.junit.Test; @@ -20,40 +23,48 @@ public class OverloadingTest extends BytecodeTest{ @Test public void testString() { try{ - Class cls = getClassToTest(); + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + Object obj = cls.newInstance(); - Vector stringVector = new Vector(); + File file = new File(rootDirectory); + URL url = file.toURL(); + URL[] urls = new URL[]{url}; + + Class stringVector = classLoader.loadClass("java%util%Vector%%java%lang%String%"); Class[] params = new Class[1]; - params[0] = stringVector.getClass(); + params[0] = stringVector; Method method = cls.getDeclaredMethod("method", params); - method.invoke(obj, stringVector); + method.invoke(obj, stringVector.newInstance()); assertTrue(true); }catch(Exception e){ - e.printStackTrace(); - fail(); + throw new RuntimeException(e); } } @Test public void testInteger() { try{ - Class cls = getClassToTest(); + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + Object obj = cls.newInstance(); - - Vector stringVector = new Vector(); + + Class integerVector = classLoader.loadClass("java%util%Vector%%java%lang%Integer%"); Class[] params = new Class[1]; - params[0] = stringVector.getClass(); + params[0] = integerVector; Method method = cls.getDeclaredMethod("method", params); - method.invoke(obj, stringVector); + method.invoke(obj, integerVector.newInstance()); assertTrue(true); }catch(Exception e){ - e.printStackTrace(); - fail(); + throw new RuntimeException(e); } } diff --git a/test/bytecode/types/ReflectionTest.java b/test/bytecode/types/ReflectionTest.java new file mode 100644 index 00000000..db5a25e2 --- /dev/null +++ b/test/bytecode/types/ReflectionTest.java @@ -0,0 +1,120 @@ +package bytecode.types; + +import static org.junit.Assert.*; + +import java.io.File; +import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.Stack; +import java.util.Vector; + +import org.junit.Test; + +import bytecode.BytecodeTest; +import de.dhbwstuttgart.logger.Logger; +import de.dhbwstuttgart.logger.Section; + +public class ReflectionTest{ + @Test + public void testUntypedVectorDeclaredMethods() { + try{ + File file = new File(System.getProperty("user.dir")+"/test/bytecode/types/"); + URL url = file.toURL(); + URL[] urls = new URL[]{url}; + + ClassLoader classLoader = new URLClassLoader(urls); + + Class untypedVectorTest = classLoader.loadClass("UntypedVector"); + + for(Method method: untypedVectorTest.getDeclaredMethods()){ + System.out.println(method.toGenericString()); + } + }catch(Exception e){ + throw new RuntimeException(e); + } + } + + @Test + public void testUntypedVectorDeclaredMethodsCallMethod() { + try{ + File file = new File(System.getProperty("user.dir")+"/test/bytecode/types/"); + URL url = file.toURL(); + URL[] urls = new URL[]{url}; + + ClassLoader classLoader = new URLClassLoader(urls); + + Class untypedVectorTest = classLoader.loadClass("UntypedVector"); + + Class stringVector = classLoader.loadClass("java%util%Vector%%java%lang%Object%"); + Object stringVectorObj = stringVector.newInstance(); + + for(Method method: untypedVectorTest.getDeclaredMethods()){ + method.invoke(untypedVectorTest.newInstance(), stringVectorObj); + } + }catch(Exception e){ + throw new RuntimeException(e); + } + } + + @Test + public void testUntypedVectorMethod() { + try{ + File file = new File(System.getProperty("user.dir")+"/test/bytecode/types/"); + URL url = file.toURL(); + URL[] urls = new URL[]{url}; + + ClassLoader classLoader = new URLClassLoader(urls); + + Class untypedVectorTest = classLoader.loadClass("UntypedVector"); + + Class stringVector = classLoader.loadClass("java%util%Vector%%java%lang%Object%"); + + Class[] params = new Class[1]; + params[0] = stringVector; + + Method method = untypedVectorTest.getDeclaredMethod("method", params); + method.invoke(untypedVectorTest.newInstance(), stringVector.newInstance()); + }catch(Exception e){ + throw new RuntimeException(e); + } + } + + @Test + public void testStdVectorAdd() { + try{ + Vector vector = new Vector(); + + Class vectorClass = vector.getClass(); + + String helloWorld = new String("Hello World!"); + + Class[] params = new Class[1]; + params[0] = new Object().getClass(); + + Method method = vectorClass.getDeclaredMethod("add", params); + method.invoke(vector, helloWorld); + }catch(Exception e){ + throw new RuntimeException(e); + } + } + + @Test + public void testStdVectorEnsureCapacity() { + try{ + Vector vector = new Vector(); + + Class vectorClass = vector.getClass(); + + Integer integer = new Integer(1); + + Class[] params = new Class[1]; + params[0] = int.class; + + Method method = vectorClass.getDeclaredMethod("ensureCapacity", params); + method.invoke(vector, integer); + }catch(Exception e){ + throw new RuntimeException(e); + } + } +} diff --git a/test/bytecode/types/Test.java b/test/bytecode/types/Test.java deleted file mode 100644 index 78235be2..00000000 --- a/test/bytecode/types/Test.java +++ /dev/null @@ -1,12 +0,0 @@ -import java.util.Vector; - -public class Test { - - public static void main(String[] args) { - Overloading o = new Overloading(); - Vector stringVector = new Vector(); - - o.method(stringVector); - } - -}