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

Merge branch 'unify' of ssh://i13029@gohorb.ba-horb.de/bahome/projekt/git/JavaCompilerCore into unify

Browse Source
This commit is contained in:
Florian Steurer 2016-05-03 13:43:16 +02:00
commit 84176275be
142 changed files with 2420 additions and 1181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
BCEL/bcelifier/IfStatement.java Normal file
View File

@ -0,0 +1,12 @@
package bcelifier;
class IfStatement{
Integer methode(Boolean b){
if(b){
return 1;
}else{
return 2;
}
}
}

71
BCEL/bcelifier/IfStatementCreator.java Normal file
View File

@ -0,0 +1,71 @@
package bcelifier;
import org.apache.commons.bcel6.generic.*;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.bytecode.MethodGenerator;
import de.dhbwstuttgart.typeinference.TypeinferenceResults;
import org.apache.commons.bcel6.*;
import java.io.*;
public class IfStatementCreator {
private InstructionFactory _factory;
private ConstantPoolGen _cp;
private ClassGenerator _cg;
public IfStatementCreator() {
TypeinferenceResults typeinferenceResults = null;
_cg = new ClassGenerator("bcelifier.IfStatement", new RefType("java.lang.Object", null, 0), "IfStatement.java", Const.ACC_SUPER, new String[] { }, typeinferenceResults);
_cp = _cg.getConstantPool();
_factory = new InstructionFactory(_cg, _cp);
}
public void create(OutputStream out) throws IOException {
createMethod_0();
createMethod_1();
_cg.getJavaClass().dump(out);
}
private void createMethod_0() {
InstructionList il = new InstructionList();
MethodGen method = new MethodGenerator(0, Type.VOID, new Type[] { new ObjectType("java.lang.Boolean") }, new String[] { "arg0" }, "<init>", "bcelifier.IfStatement", il, _cp);
InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
il.append(_factory.createInvoke("java.lang.Object", "<init>", Type.VOID, Type.NO_ARGS, Const.INVOKESPECIAL));
InstructionHandle ih_4 = il.append(_factory.createReturn(Type.VOID));
method.setMaxStack();
method.setMaxLocals();
_cg.addMethod(method.getMethod());
}
private void createMethod_1() {
InstructionList il = new InstructionList();
MethodGen method = new MethodGenerator(0, new ObjectType("java.lang.Integer"), new Type[] { new ObjectType("java.lang.Boolean") }, new String[] { "arg0" }, "methode", "bcelifier.IfStatement", il, _cp);
il.append(InstructionFactory.createLoad(Type.OBJECT, 1));
il.append(_factory.createInvoke("java.lang.Boolean", "booleanValue", Type.BOOLEAN, Type.NO_ARGS, Const.INVOKEVIRTUAL));
BranchInstruction ifeq_4 = InstructionFactory.createBranchInstruction(Const.IFEQ, null);
il.append(ifeq_4);
il.append(new PUSH(_cp, 1));
il.append(_factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new Type[] { Type.INT }, Const.INVOKESTATIC));
il.append(InstructionFactory.createReturn(Type.OBJECT));
InstructionHandle ih_12 = il.append(new PUSH(_cp, 2));
il.append(_factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new Type[] { Type.INT }, Const.INVOKESTATIC));
il.append(InstructionFactory.createReturn(Type.OBJECT));
ifeq_4.setTarget(ih_12);
method.setMaxStack();
method.setMaxLocals();
_cg.addMethod(method.getMethod());
}
public static void main(String[] args) throws Exception {
bcelifier.IfStatementCreator creator = new bcelifier.IfStatementCreator();
creator.create(new FileOutputStream("bcelifier.IfStatement.class"));
System.out.println("bcelifier.IfStatement.class");
}
}

20
BCEL/bcelifier/JavaToBCEL.java
View File

@ -24,16 +24,16 @@ public class JavaToBCEL {
public JavaToBCEL(){
try {
//new BCELifier(new ClassParser(rootDirectory+"Lambda1.class").parse(), new FileOutputStream(new File(rootDirectory+"Lambda1Creator.java"))).start();
new BCELifier(new ClassParser(rootDirectory+"This.class").parse(), new FileOutputStream(new File(rootDirectory+"ThisCreator.java"))).start();
new BCELifier(new ClassParser(rootDirectory+"IntLiteral.class").parse(), new FileOutputStream(new File(rootDirectory+"IntLiteralCreator.java"))).start();
new BCELifier(new ClassParser(rootDirectory+"MethodCall.class").parse(), new FileOutputStream(new File(rootDirectory+"MethodCallCreator.java"))).start();
new BCELifier(new ClassParser(rootDirectory+"FieldDeclaration.class").parse(), new FileOutputStream(new File(rootDirectory+"FieldDeclarationCreator.java"))).start();
new BCELifier(new ClassParser(rootDirectory+"Null.class").parse(), new FileOutputStream(new File(rootDirectory+"NullCreator.java"))).start();
new BCELifier(new ClassParser(rootDirectory+"LocalVarAccess.class").parse(), new FileOutputStream(new File(rootDirectory+"LocalVarAccessCreator.java"))).start();
new BCELifier(new ClassParser(rootDirectory+"Wildcard.class").parse(), new FileOutputStream(new File(rootDirectory+"WildcardCreator.java"))).start();
new BCELifier(new ClassParser(rootDirectory+"BooleanValue.class").parse(), new FileOutputStream(new File(rootDirectory+"BooleanValueCreator.java"))).start();
new BCELifier(new ClassParser(rootDirectory+"NewClass.class").parse(), new FileOutputStream(new File(rootDirectory+"NewClassCreator.java"))).start();
//new BCELifier(new ClassParser(rootDirectory+"This.class").parse(), new FileOutputStream(new File(rootDirectory+"ThisCreator.java"))).start();
//new BCELifier(new ClassParser(rootDirectory+"IntLiteral.class").parse(), new FileOutputStream(new File(rootDirectory+"IntLiteralCreator.java"))).start();
//new BCELifier(new ClassParser(rootDirectory+"MethodCall.class").parse(), new FileOutputStream(new File(rootDirectory+"MethodCallCreator.java"))).start();
//new BCELifier(new ClassParser(rootDirectory+"FieldDeclaration.class").parse(), new FileOutputStream(new File(rootDirectory+"FieldDeclarationCreator.java"))).start();
//new BCELifier(new ClassParser(rootDirectory+"Null.class").parse(), new FileOutputStream(new File(rootDirectory+"NullCreator.java"))).start();
//new BCELifier(new ClassParser(rootDirectory+"LocalVarAccess.class").parse(), new FileOutputStream(new File(rootDirectory+"LocalVarAccessCreator.java"))).start();
//new BCELifier(new ClassParser(rootDirectory+"Wildcard.class").parse(), new FileOutputStream(new File(rootDirectory+"WildcardCreator.java"))).start();
//new BCELifier(new ClassParser(rootDirectory+"BooleanValue.class").parse(), new FileOutputStream(new File(rootDirectory+"BooleanValueCreator.java"))).start();
//new BCELifier(new ClassParser(rootDirectory+"NewClass.class").parse(), new FileOutputStream(new File(rootDirectory+"NewClassCreator.java"))).start();
new BCELifier(new ClassParser(rootDirectory+"IfStatement.class").parse(), new FileOutputStream(new File(rootDirectory+"IfStatementCreator.java"))).start();
} catch (ClassFormatException | IOException e) {
e.printStackTrace();
}

BIN
lib/commons-bcel6-6.0-SNAPSHOT.jar
View File

Binary file not shown.

4
src/de/dhbwstuttgart/bytecode/ClassGenerator.java
View File

@ -68,7 +68,7 @@ public class ClassGenerator extends ClassGen{
//return getNearestType((TypePlaceholder) t);
return new TypePlaceholderType((TypePlaceholder) t);
}else{
return t.getBytecodeType(this, getTypeinferenceResults().getTypeReconstructions().firstElement());
return t.getBytecodeType(this, getTypeinferenceResults().getTypeReconstructions().get(0));
}
}
public org.apache.commons.bcel6.generic.Type getNearestUsedType(TypePlaceholder toTPH){
@ -150,7 +150,7 @@ public class ClassGenerator extends ClassGen{
TypePlaceholder tph = it.next();
//ret += tph.getBytecodeMethodSignature(this);
//ret += ":";
ret += tph.getClassSignature(this, getTypeinferenceResults().getTypeReconstructions().firstElement());
ret += tph.getClassSignature(this, getTypeinferenceResults().getTypeReconstructions().get(0));
}
ret += ">";
}

17
src/de/dhbwstuttgart/bytecode/DHBWInstructionFactory.java
View File

@ -139,13 +139,18 @@ public class DHBWInstructionFactory extends InstructionFactory{
return new INVOKEDYNAMIC(index);
}
public LocalVariableInstruction createLoad(org.apache.commons.bcel6.generic.Type bytecodeType, String variableName) {
return InstructionFactory.createLoad(bytecodeType, storeIndexes.get(variableName));
public static LocalVariableInstruction createLoad(org.apache.commons.bcel6.generic.Type bytecodeType, String variableName) {
return InstructionFactory.createLoad(bytecodeType, getStoreIndex(variableName));
}
public Integer getStoreIndex(String variableName) {
if(!storeIndexes.containsKey(variableName)){
storeIndexes.put(variableName, storeIndexes.size()+1);
public LocalVariableInstruction createStore(org.apache.commons.bcel6.generic.Type bytecodeType, String variableName) {
return InstructionFactory.createStore(bytecodeType, getStoreIndex(variableName));
}
public static Integer getStoreIndex(String variableName) {
if(storeIndexes.get(variableName) == null){
Integer index = storeIndexes.size()+1;
storeIndexes.put(variableName, index);
}
return storeIndexes.get(variableName);
@ -160,6 +165,6 @@ public class DHBWInstructionFactory extends InstructionFactory{
}
public void resetStoreIndexes() {
storeIndexes = new HashMap<>();
//storeIndexes.clear();
}
}

2
src/de/dhbwstuttgart/bytecode/MethodGenerator.java
View File

@ -74,7 +74,7 @@ public class MethodGenerator extends MethodGen{
method.addAttribute(factory.createSignatureAttribute(paramTypesSig+retTypeSig));
StackMap stackMap = new StackMapTableGen(this.getInstructionList(), cp).getStackMap();
StackMap stackMap = new StackMapTableGen(this, cp).getStackMap();
if(stackMap != null)method.addCodeAttribute(stackMap);
return method.getMethod();

48
src/de/dhbwstuttgart/core/MyCompiler.java
View File

@ -159,11 +159,11 @@ public class MyCompiler implements MyCompilerAPI{
FunNInterface funN = new FunNInterface(i);
ret.add(funN.getPublicFieldAssumptions());
}
for(int i = 0; i<6; i++){
FunVoidNInterface funN = new FunVoidNInterface(i);
ret.add(funN.getPublicFieldAssumptions());
}
//Keine FunVoidInterfaces in den Assumptions.
//for(int i = 0; i<6; i++){
// FunVoidNInterface funN = new FunVoidNInterface(i);
// ret.add(funN.getPublicFieldAssumptions());
//}
return ret;
}
@ -209,43 +209,6 @@ public class MyCompiler implements MyCompilerAPI{
return OutputDir;
}
/**
* @author Arne Lüdtke
* Ersetzt alle GTVs durch TPHs mit gleichem Namen. Arbeitet Rekursiv.
* ACHTUNG: BACKDOOR CREATE!!! Nur für Testzwecke verwenden.
* @param T - Typ, bei welchem die GTVs ersetzt werden sollen.
*/
public static Type makeGenericTypeVars2TypePlaceHolders(Type T)
{
if(T instanceof RefType)
{
RefType refT = (RefType)T;
if(refT.get_ParaList() != null)
{
Menge<Type> paras = refT.get_ParaList();
for(int i = 0; i<paras.size();i++)
{
Type tt = paras.elementAt(i);
if(tt instanceof GenericTypeVar)
{
GenericTypeVar gtv = (GenericTypeVar)tt;
paras.set(i,TypePlaceholder.backdoorCreate(gtv.getName().toString()));
}
else
{
makeGenericTypeVars2TypePlaceHolders(tt);
}
}
}
}
else if(T instanceof IMatchable)
{
Type TT = ((IMatchable)T).getMatchType();
makeGenericTypeVars2TypePlaceHolders(TT);
}
return T;
}
/**
* Parst den Inhalt einer Datei zu einem Syntaxbaum.
*/
@ -328,3 +291,4 @@ public class MyCompiler implements MyCompilerAPI{
return ret;
}
}

1
src/de/dhbwstuttgart/logger/Logger.java
View File

@ -94,6 +94,7 @@ public class Logger {
public static String getWholeLog(){
String ret = "";
LOG_HISTORY.removeIf((logLine)->logLine==null);
Logger.LOG_HISTORY.sort((log1, log2)->log1.timestamp.compareTo(log2.timestamp));
ret += Logger.LOG_HISTORY.toString();
return ret;

4
src/de/dhbwstuttgart/syntaxtree/Class.java
View File

@ -111,7 +111,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
}
InstructionList fieldInitializations = new InstructionList();
for(FieldDeclaration f : fieldDeclarations){
fieldInitializations.append(f.genByteCode(_cg, typeinferenceResults.getTypeReconstructions().firstElement()));
fieldInitializations.append(f.genByteCode(_cg, typeinferenceResults.getTypeReconstructions().get(0)));
}
//Die Konstruktoren müssen die Feld initialisierungswerte beinhalten:
for(Constructor c : constructors){
@ -554,7 +554,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
*/
// ino.method.get_ParaList.23101.definition
public Menge<? extends Type> get_ParaList()
public List<? extends Type> get_ParaList()
// ino.end
// ino.method.get_ParaList.23101.body
{

58
src/de/dhbwstuttgart/syntaxtree/ClassBody.java
View File

@ -85,64 +85,6 @@ Paratyp gesetzt."); }
fielddecl.addElement(i);
}
// ino.method.is_declared.23188.defdescription type=line
//
// ********************************************************************************************
//
// ino.end
// ino.method.is_declared.23188.definition
public boolean is_declared(Type t, Menge<Class> classlist)
throws SCClassBodyException
// ino.end
// ino.method.is_declared.23188.body
{
boolean flag=false;
for(Enumeration<Class> e = classlist.elements();e.hasMoreElements();)
{
flag = false;
Class c = e.nextElement();
// System.out.println("is_init: vergleiche "+t.get_Type_()+" mit "+c.getName());
if(c.getName().equals(t.getName())){
// System.out.println("Klasse "+t.get_Type()+"im Menge classlist gefunden.");
flag = true;
break;
}
}
if( t instanceof RefType && ((RefType)t).get_ParaList()!=null)
{
if( ((RefType)t).get_ParaList().size() > 0 )
{
for(Enumeration e1 = ((RefType)t).get_ParaList().elements(); e1.hasMoreElements(); )
{
try
{
is_declared((Type)e1.nextElement(),classlist);
}
catch(SCClassBodyException ex)
{
throw ex;
}
}
}
}
if(flag)
return true;
else
{
SCClassBodyException ex = new SCClassBodyException();
SCExcept e = new SCExcept();
e.set_error("unbekannte Klasse "+t.getName()+".");
e.set_function("complete_parahashtable() --> is_declared()");
e.set_statement(t.getName().toString());
ex.addException(e);
throw ex;
}
}
// ino.end
// ino.method.string_rec.23191.definition
static String string_rec(Hashtable ht)

2
src/de/dhbwstuttgart/syntaxtree/FormalParameter.java
View File

@ -237,7 +237,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().getBytecodeSignature(null, null);
ret += this.getType().toString();//getBytecodeSignature(null, null);
}
return ret+this.getIdentifier();
}

280
src/de/dhbwstuttgart/syntaxtree/Method.java
View File

@ -1,9 +1,8 @@
// ino.module.Method.8564.package
package de.dhbwstuttgart.syntaxtree;
import java.util.ArrayList;
import java.util.Arrays;
// ino.end
// ino.module.Method.8564.import
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
@ -65,58 +64,23 @@ import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertPoint;
*
*/
public class Method extends Field implements IItemWithOffset, TypeInsertable
// ino.end
// ino.class.Method.23482.body
{
// ino.attribute.block.23488.declaration
private Block block;
// ino.end
// ino.attribute.parameterlist.23491.declaration
public ParameterList parameterlist = new ParameterList();
// ino.end
// ino.attribute.exceptionlist.23494.declaration
private ExceptionList exceptionlist;
// ino.end
// ino.attribute.returntype.23497.declaration
private Type returntype;
// ino.end
// ino.attribute.genericMethodParameters.23500.decldescription type=javadoc
/**
* HOTI 4.5.06 Dieser Vektor beinhaltet alle Generischen Typen und v.a. die
* F-Bounded-Generics, die die Methode besitzt size()==0, falls es keine
* gibt
*/
// ino.end
// ino.attribute.genericMethodParameters.23500.declaration
// private Menge<GenericTypeVar> genericMethodParameters=new
// Menge<GenericTypeVar>();
// ino.end
// ino.attribute.overloadedID.23503.declaration
private int overloadedID;
// ino.end
// ino.attribute.isAbstract.23506.declaration
private boolean isAbstract = false;
// ino.end
// ino.attribute.types_in_parameterlist.23509.declaration
private Menge<String> types_in_parameterlist = new Menge<String>();
// ino.end
// ino.attribute.m_LineNumber.23512.declaration
private int m_LineNumber = MyCompiler.NO_LINENUMBER;
// ino.end
private int m_Offset = -1; // hinzugef�gt hoth: 07.04.2006
private Modifiers modifiers;
// ino.attribute.inferencelog.23515.declaration
protected static Logger inferencelog = Logger.getLogger("inference");
// ino.end
// ino.attribute.parserlog.23518.declaration
protected static Logger parserlog = Logger.getLogger("parser");
protected Menge<org.apache.commons.bcel6.generic.Type[]> createdMethods = new Menge<>();
// ino.end
public Method(int offset) {
super(offset);
}
@ -136,51 +100,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
this.setReturnType(returnType);
}
/*
* // ino.method.setGenericMethodParameters.23521.definition public void
* setGenericMethodParameters(Menge<GenericTypeVar> genericMethodParameters)
* // ino.end // ino.method.setGenericMethodParameters.23521.body {
* this.genericMethodParameters=genericMethodParameters; } // ino.end //
* ino.method.getGenericMethodParameters.23524.definition public
* Menge<GenericTypeVar> getGenericMethodParameters() // ino.end //
* ino.method.getGenericMethodParameters.23524.body {
* return(genericMethodParameters); } // ino.end
*/
/*
* // ino.method.sc_init_parameterlist.23530.definition public void
* sc_init_parameterlist(boolean ext) // ino.end //
* ino.method.sc_init_parameterlist.23530.body { DeclId hilf=null;
* Menge<FormalParameter> list; FormalParameter para; String typeofpara; int
* i=1; if(this.getParameterList()!=null) //es gibt Parameter, dann: {
* hilf=declid.elementAt(0); if(ext)
* parserlog.debug("Semantik-Check hat in Methode "
* +hilf.get_Name()+" bergabewerte gefunden:");
* list=this.getParameterList().sc_get_Formalparalist(); //Menge
* Formalparalist aus FormalParameterList wird zwischen gesichert
* for(Enumeration<FormalParameter> el2=list.elements();
* el2.hasMoreElements();) { para=el2.nextElement();
* typeofpara=para.getTypeName(); if(ext)
* parserlog.debug(" "+i+". Parameter hat Typ "+typeofpara);
* types_in_parameterlist.addElement(typeofpara); //Typ der Parameter werden
* im Menge abgelegt i++; } } else //keine Parameter vorhanden: { if(ext) {
* hilf=declid.elementAt(0);
* parserlog.debug("Semantik-Check hat in Methode "
* +hilf.get_Name()+" keine bergabewerte gefunden."); } } if(ext) {
* parserlog.debug("Semantik-Check hat in Methode "+hilf.get_Name()+" "+
* types_in_parameterlist.size()+" bergabeparameter gefunden.");
* parserlog.debug
* (" namentlich: "+types_in_parameterlist.toString()); } } //
* ino.end
*/
// ino.method.getTypeName.23533.defdescription type=line
// Eine der beiden Funktionen ist ueberflssig. Wer sich daran strt kann die
// get_ReturnType() auf eigene Gefahr lschen.
// ino.end
// ino.method.getTypeName.23533.definition
public JavaClassName getTypeName()
// ino.end
// ino.method.getTypeName.23533.body
{
if (this.getType() == null)
return null;
@ -188,101 +108,58 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
return this.getType().getName();
}
// ino.end
// ino.method.get_Block.23536.definition
public Block get_Block()
// ino.end
// ino.method.get_Block.23536.body
{
return block;
}
// ino.end
// ino.method.setReturnType.23539.defdescription type=javadoc
/**
* <br/>
* Author: Jrg Buerle
*
* @param type
*/
// ino.end
// ino.method.setReturnType.23539.definition
private void setReturnType(Type type)
// ino.end
// ino.method.setReturnType.23539.body
{
this.returntype = type;
}
// ino.end
// ino.method.set_Block.23542.definition
public void set_Block(Block blo)
// ino.end
// ino.method.set_Block.23542.body
{
if (blo.getType() == null)
blo.setType(this.returntype);
this.block = blo;
}
// ino.end
// ino.method.set_Modifiers.23545.definition
public void set_Modifiers(Modifiers modif)
// ino.end
// ino.method.set_Modifiers.23545.body
{
declid.firstElement().set_Modifiers(modif);
this.modifiers = modif;
}
// ino.end
// ino.method.set_ExceptionList.23548.definition
public void set_ExceptionList(ExceptionList exlist)
// ino.end
// ino.method.set_ExceptionList.23548.body
{
this.exceptionlist = exlist;
}
// ino.end
// ino.method.setParameterList.23551.definition
public void setParameterList(ParameterList paralist)
// ino.end
// ino.method.setParameterList.23551.body
{
this.parameterlist = paralist;
}
// ino.end
// ino.method.getParameterList.23554.definition
public ParameterList getParameterList()
// ino.end
// ino.method.getParameterList.23554.body
{
// otth: gibt die Parameterliste zurueck
return this.parameterlist;
}
// ino.end
// ino.method.getParameterCount.23557.defdescription type=javadoc
/**
* Author: Jrg Buerle<br/>
*
* @return Die Anzahl der Methoden-Paramater
*/
// ino.end
// ino.method.getParameterCount.23557.definition
public int getParameterCount()
// ino.end
// ino.method.getParameterCount.23557.body
{
if (this.getParameterList() == null)
return 0;
@ -290,177 +167,94 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
return this.getParameterList().getParameterCount();
}
// ino.end
// ino.method.get_ExceptionList.23560.definition
public ExceptionList get_ExceptionList()
// ino.end
// ino.method.get_ExceptionList.23560.body
{
// otth: gibt die Exceptionliste zurueck
return this.exceptionlist;
}
// ino.end
// ino.method.getOverloadedID.23563.definition
public int getOverloadedID()
// ino.end
// ino.method.getOverloadedID.23563.body
{
return (overloadedID);
}
// ino.end
// ino.method.setOverloadedID.23566.definition
public void setOverloadedID(int overloadedID)
// ino.end
// ino.method.setOverloadedID.23566.body
{
this.overloadedID = overloadedID;
}
// ino.end
// ino.method.get_Method_Name.23575.definition
public String get_Method_Name()
// ino.end
// ino.method.get_Method_Name.23575.body
{
DeclId hilf = declid.elementAt(0);
return hilf.get_Name();
}
// ino.end
// ino.method.get_Type_Paralist.23578.definition
public Menge get_Type_Paralist()
// ino.end
// ino.method.get_Type_Paralist.23578.body
{
return types_in_parameterlist;
}
// ino.end
// ino.method.getLineNumber.23584.definition
public int getLineNumber()
// ino.end
// ino.method.getLineNumber.23584.body
{
return m_LineNumber;
}
// ino.end
// ino.method.setLineNumber.23587.definition
public void setLineNumber(int lineNumber)
// ino.end
// ino.method.setLineNumber.23587.body
{
m_LineNumber = lineNumber;
}
// ino.end
// ino.method.getOffset.23590.defdescription type=line
// hinzugef�gt hoth: 07.04.2006
// ino.end
// ino.method.getOffset.23590.definition
public int getOffset()
// ino.end
// ino.method.getOffset.23590.body
{
return m_Offset;
}
// ino.end
// ino.method.getVariableLength.23593.definition
public int getVariableLength()
// ino.end
// ino.method.getVariableLength.23593.body
{
return get_Method_Name().length();
}
// ino.end
// ino.method.setOffset.23596.defdescription type=line
// hinzugef�gt hoth: 07.04.2006
// ino.end
// ino.method.setOffset.23596.definition
public void setOffset(int Offset)
// ino.end
// ino.method.setOffset.23596.body
{
m_Offset = Offset;
}
// ino.end
// ino.method.getTypeLineNumber.23602.defdescription type=javadoc
/**
* <br>
* Author: Jrg Buerle
*
* @return
*/
// ino.end
// ino.method.getTypeLineNumber.23602.definition
public int getTypeLineNumber()
// ino.end
// ino.method.getTypeLineNumber.23602.body
{
return this.getLineNumber();
}
// ino.end
// ino.method.toString.23605.defdescription type=javadoc
/**
* <br/>
* Author: Martin Pl�micke
*
* @return
*/
// ino.end
// ino.method.toString.23605.definition
public String toString()
// ino.end
// ino.method.toString.23605.body
{
return this.getType() + " " + this.get_Name() + ((block != null) ? block.toString() : "");
}
// ino.end
// ino.method.setAbstract.23608.defdescription type=javadoc
/**
* Legt fuer die ByteCodeGen fest, ob Bytecode innerhalb der Methode
* generiert wird.
*/
// ino.end
// ino.method.setAbstract.23608.definition
public void setAbstract(boolean b)
// ino.end
// ino.method.setAbstract.23608.body
{
isAbstract = b;
}
// ino.end
// ino.method.isAbstract.23611.defdescription type=javadoc
/**
* Gibt zurueck, ob ByteCode innerhabl der Methode generiert wird.
*/
// ino.end
// ino.method.isAbstract.23611.definition
public boolean isAbstract()
// ino.end
// ino.method.isAbstract.23611.body
{
return isAbstract;
}
@ -610,44 +404,40 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
public void genByteCode(ClassGenerator cg, Class classObj) {
List<TypeinferenceResultSet> typeInterferenceResults = cg.getTypeinferenceResults().getTypeReconstructions(this, cg);
DHBWInstructionFactory _factory = cg.getInstructionFactory();
for(TypeinferenceResultSet t: typeInterferenceResults){
DHBWConstantPoolGen _cp = cg.getConstantPool();
InstructionList il = new InstructionList();
Class parentClass = this.getParentClass();
//Die Argumentliste generieren:
org.apache.commons.bcel6.generic.Type[] argumentTypes = org.apache.commons.bcel6.generic.Type.NO_ARGS;
String[] argumentNames = new String[]{};
if(this.parameterlist != null && this.parameterlist.size() > 0){
argumentTypes = new org.apache.commons.bcel6.generic.Type[this.parameterlist.size()];
argumentNames = new String[this.parameterlist.size()];
int i = 0;
for(FormalParameter parameter : this.parameterlist){
argumentTypes[i] = parameter.getType().getBytecodeType(cg, t);
argumentNames[i] = parameter.getIdentifier();
i++;
}
}
String nameAndSignature = get_Method_Name()+Arrays.toString(argumentTypes);
Logger.getLogger("nameAndSignature").error(nameAndSignature, Section.CODEGEN);
addMethodToClassGenerator(cg, _factory, t);
}
}
short constants = Constants.ACC_PUBLIC; //Per Definition ist jede Methode public
if(this.modifiers != null && this.modifiers.includesModifier(new Static())) constants += Constants.ACC_STATIC;
Type returnType = this.getType();
private void addMethodToClassGenerator(ClassGenerator cg, DHBWInstructionFactory _factory, TypeinferenceResultSet t) {
DHBWConstantPoolGen _cp = cg.getConstantPool();
InstructionList il = new InstructionList();
ArrayList<org.apache.commons.bcel6.generic.Type> argumentTypes = new ArrayList<org.apache.commons.bcel6.generic.Type>();
ArrayList<String> argumentNames = new ArrayList<String>();
if(this.parameterlist != null && this.parameterlist.size() > 0){
generateArgumentList(argumentTypes, argumentNames, cg, _factory, t);
}
short constants = Constants.ACC_PUBLIC;
if(this.modifiers != null && this.modifiers.includesModifier(new Static())) constants += Constants.ACC_STATIC;
Type returnType = this.getType();
MethodGenerator method = new MethodGenerator(constants, returnType.getBytecodeType(cg, t), argumentTypes.toArray(new org.apache.commons.bcel6.generic.Type[parameterlist.size()]) , argumentNames.toArray(new String[parameterlist.size()]), this.get_Method_Name(), getParentClass().name, il, _cp);
cg.addMethod(method.createMethod(cg, getParameterList(), returnType, get_Block(), t));
}
private void generateArgumentList(ArrayList<org.apache.commons.bcel6.generic.Type> argumentTypes, ArrayList<String> argumentNames, ClassGenerator cg, DHBWInstructionFactory _factory, TypeinferenceResultSet t) {
for(FormalParameter parameter : this.parameterlist){
argumentTypes.add(parameter.getType().getBytecodeType(cg, t));
argumentNames.add(parameter.getIdentifier());
//Methode generieren:
MethodGenerator method = new MethodGenerator(constants, returnType.getBytecodeType(cg, t), argumentTypes , argumentNames, this.get_Method_Name(), parentClass.name, il, _cp);
//Methode generieren und anfügen:
cg.addMethod(method.createMethod(cg, getParameterList(), returnType, get_Block(), t));
Logger.getLogger("createMethod").debug(this.toString(), Section.CODEGEN);
_factory.getStoreIndex(parameter.getIdentifier());
}
}
}
// ino.end

5
src/de/dhbwstuttgart/syntaxtree/SourceFile.java
View File

@ -39,17 +39,12 @@ import de.dhbwstuttgart.syntaxtree.type.Void;
import de.dhbwstuttgart.typeinference.ByteCodeResult;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.FunNInterface;
import de.dhbwstuttgart.typeinference.FunNMethod;
import de.dhbwstuttgart.typeinference.KomplexeMenge;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResults;
import de.dhbwstuttgart.typeinference.UndConstraint;
import de.dhbwstuttgart.typeinference.UnifyConstraintsSet;
import de.dhbwstuttgart.typeinference.assumptions.ClassAssumption;
import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
import de.dhbwstuttgart.typeinference.assumptions.ParameterAssumption;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;

57
src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java
View File

@ -1,17 +1,21 @@
package de.dhbwstuttgart.syntaxtree.factory;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.logging.Logger;
import de.dhbwstuttgart.myexception.NotImplementedException;
import de.dhbwstuttgart.syntaxtree.NullSyntaxTreeNode;
import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
import de.dhbwstuttgart.syntaxtree.type.FunN;
import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar;
import de.dhbwstuttgart.syntaxtree.type.ObjectType;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.syntaxtree.type.Void;
import de.dhbwstuttgart.syntaxtree.type.WildcardType;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.EinzelElement;
@ -29,6 +33,7 @@ import de.dhbwstuttgart.typeinference.assumptions.ClassAssumption;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.model.ExtendsType;
import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
import de.dhbwstuttgart.typeinference.unify.model.FunNType;
import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
@ -67,18 +72,20 @@ public class UnifyTypeFactory {
//Es wurde versucht ein Typ umzuwandeln, welcher noch nicht von der Factory abgedeckt ist
if(t instanceof GenericTypeVar){
return UnifyTypeFactory.convert((GenericTypeVar)t);
}else if(t instanceof RefType){
return UnifyTypeFactory.convert((RefType)t);
}else if(t instanceof FunN){
return UnifyTypeFactory.convert((FunN)t);
}else if(t instanceof TypePlaceholder){
return UnifyTypeFactory.convert((TypePlaceholder)t);
}else if(t instanceof ExtendsWildcardType){
return UnifyTypeFactory.convert((ExtendsWildcardType)t);
}else if(t instanceof SuperWildcardType){
return UnifyTypeFactory.convert((SuperWildcardType)t);
}else if(t instanceof RefType){
return UnifyTypeFactory.convert((RefType)t);
}
throw new NotImplementedException("Der Typ "+t+" kann nicht umgewandelt werden");
}
public static UnifyType convert(RefType t){
UnifyType ret;
if(t.getParaList() != null && t.getParaList().size() > 0){
@ -92,6 +99,18 @@ public class UnifyTypeFactory {
}
return ret;
}
public static UnifyType convert(FunN t){
UnifyType ret;
Menge<UnifyType> params = new Menge<>();
if(t.getParaList() != null && t.getParaList().size() > 0){
for(Type pT : t.getParaList()){
params.add(UnifyTypeFactory.convert(pT));
}
}
ret = FunNType.getFunNType(new TypeParams(params));
return ret;
}
public static UnifyType convert(TypePlaceholder tph){
return new PlaceholderType(tph.get_Name());
@ -106,7 +125,8 @@ public class UnifyTypeFactory {
}
public static UnifyType convert(GenericTypeVar t){
return new PlaceholderType(t.get_Name());
//return new PlaceholderType(t.get_Name());
return new ReferenceType(t.get_Name());
}
public static UnifyConstraintsSet convert(ConstraintsSet constraints) {
@ -151,7 +171,17 @@ public class UnifyTypeFactory {
}
public static Type convert(ReferenceType t) {
return new RefType(t.getName(),null,0);
//TODO: Hier kann man die GTVs extrahieren
if(t.getName() == "void")return new Void(NULL_NODE, 0);
RefType ret = new RefType(t.getName(),null,0);
ret.set_ParaList(convert(t.getTypeParams()));
return ret;
}
public static Type convert(FunNType t) {
RefType ret = new RefType(t.getName(),null,0);
ret.set_ParaList(convert(t.getTypeParams()));
return ret;
}
public static Type convert(SuperType t) {
@ -165,14 +195,29 @@ public class UnifyTypeFactory {
}
public static Type convert(PlaceholderType t) {
return TypePlaceholder.getInstance(t.getName());
TypePlaceholder ret = TypePlaceholder.getInstance(t.getName());
if(ret == null){ //Dieser TPH wurde vom Unifikationsalgorithmus erstellt
ret = TypePlaceholder.fresh(NULL_NODE);
}
return ret;
}
public static Type convert(UnifyType t) {
if(t instanceof FunNType)return convert((FunNType) t);
if(t instanceof ReferenceType)return convert((ReferenceType) t);
if(t instanceof SuperType)return convert((SuperType) t);
if(t instanceof ExtendsType)return convert((ExtendsType) t);
if(t instanceof PlaceholderType)return convert((PlaceholderType) t);
throw new NotImplementedException("Der Typ "+t+" kann nicht umgewandelt werden");
}
private static List<Type> convert(TypeParams typeParams) {
List<Type> ret = new ArrayList<>();
for(UnifyType uT : typeParams){
Type toAdd = convert(uT);
ret.add(toAdd);
}
return ret;
}
}

100
src/de/dhbwstuttgart/syntaxtree/operator/AddOp.java
View File

@ -5,19 +5,36 @@ package de.dhbwstuttgart.syntaxtree.operator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.Constants;
import org.apache.commons.bcel6.generic.ArithmeticInstruction;
import org.apache.commons.bcel6.generic.DUP;
import org.apache.commons.bcel6.generic.IADD;
import org.apache.commons.bcel6.generic.InstructionList;
import org.apache.commons.bcel6.generic.InvokeInstruction;
import org.apache.commons.bcel6.generic.ObjectType;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Expr;
import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
import de.dhbwstuttgart.typeinference.unify.TypeUnify;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
@ -61,5 +78,86 @@ public abstract class AddOp extends Operator
return ret;
}
@Override
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator) {
/*
0: aload_1
1: invokevirtual #2 // Method java/lang/Integer.intValue:()I
4: aload_1
5: invokevirtual #2 // Method java/lang/Integer.intValue:()I
8: iadd
9: invokestatic #3 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
12: areturn
*/
String returnType = getReturnType(operator.get_Expr1(), operator.get_Expr2(), rs);
if(returnType.equals("java.lang.String")){
DHBWInstructionFactory _factory = _cg.getInstructionFactory();
ObjectType objectType = new ObjectType("java.lang.StringBuilder");
InstructionList il = new InstructionList();
il.append(_factory.createNew("java.lang.StringBuilder"));
il.append(new DUP());
il.append(_cg.getInstructionFactory().createInvoke("java.lang.StringBuilder", "<init>", org.apache.commons.bcel6.generic.Type.VOID, new org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKESPECIAL));
il.append(operator.get_Expr1().genByteCode(_cg, rs));
il.append(_cg.getInstructionFactory().createInvoke("java.lang.StringBuilder", "append", objectType, new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.STRING}, Constants.INVOKEVIRTUAL));
il.append(operator.get_Expr2().genByteCode(_cg, rs));
il.append(_cg.getInstructionFactory().createInvoke("java.lang.StringBuilder", "append", objectType, new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.STRING}, Constants.INVOKEVIRTUAL));
il.append(_cg.getInstructionFactory().createInvoke("java.lang.StringBuilder", "toString", new ObjectType("java.lang.String"), new org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
return il;
}else{
DHBWInstructionFactory _factory = _cg.getInstructionFactory();
InstructionList il = getInstructionListForOperand(_cg, rs, operator.get_Expr1(), returnType);
il.append(getInstructionListForOperand(_cg, rs, operator.get_Expr2(), returnType));
il.append(getOperator(returnType));
il.append(convertValueToObject(_factory, returnType));
return il;
}
}
private String getReturnType(Expr expr1, Expr expr2, TypeinferenceResultSet rs) {
Type type = expr1.getType();
if(type instanceof TypePlaceholder){
Type tphType = rs.getTypeOfPlaceholder((TypePlaceholder) expr1.getType());
if(tphType instanceof ExtendsWildcardType){
return ((ExtendsWildcardType) tphType).get_ExtendsType().get_Name();
}else if(tphType instanceof SuperWildcardType){
return ((SuperWildcardType) tphType).get_SuperType().get_Name();
}else{
return tphType.getName().toString();
}
}else{
return type.get_Name();
}
}
abstract ArithmeticInstruction getOperator(String returnType);
private InvokeInstruction convertValueToObject(DHBWInstructionFactory _factory, String returnType) {
if(returnType.equals("java.lang.Integer")){
return _factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.INT}, Constants.INVOKESTATIC);
}else if(returnType.equals("java.lang.Double")){
return _factory.createInvoke("java.lang.Double", "valueOf", new ObjectType("java.lang.Double"), new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.DOUBLE}, Constants.INVOKESTATIC);
}else if(returnType.equals("java.lang.Float")){
return _factory.createInvoke("java.lang.Float", "valueOf", new ObjectType("java.lang.Float"), new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.FLOAT}, Constants.INVOKESTATIC);
}else if(returnType.equals("java.lang.Long")){
return _factory.createInvoke("java.lang.Long", "valueOf", new ObjectType("java.lang.Long"), new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.LONG}, Constants.INVOKESTATIC);
}else{
throw new NotImplementedException();
}
}
}
// ino.end

11
src/de/dhbwstuttgart/syntaxtree/operator/AndOp.java
View File

@ -3,10 +3,15 @@ package de.dhbwstuttgart.syntaxtree.operator;
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.generic.InstructionList;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Expr;
import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
// ino.class.AndOp.24101.declaration
@ -24,6 +29,12 @@ public class AndOp extends LogOp
}
// ino.end
@Override
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator) {
// TODO Auto-generated method stub
return null;
}
}
// ino.end

29
src/de/dhbwstuttgart/syntaxtree/operator/DivideOp.java
View File

@ -3,6 +3,17 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.end
// ino.module.DivideOp.8596.import
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
import org.apache.commons.bcel6.generic.ArithmeticInstruction;
import org.apache.commons.bcel6.generic.DADD;
import org.apache.commons.bcel6.generic.DDIV;
import org.apache.commons.bcel6.generic.FADD;
import org.apache.commons.bcel6.generic.FDIV;
import org.apache.commons.bcel6.generic.IADD;
import org.apache.commons.bcel6.generic.IDIV;
import org.apache.commons.bcel6.generic.LADD;
import org.apache.commons.bcel6.generic.LDIV;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
@ -25,9 +36,19 @@ public class DivideOp extends MulOp
super(offset,variableLength);
}
// ino.end
ArithmeticInstruction getOperator(String returnType) {
if(returnType.equals("java.lang.Integer")){
return new IDIV();
}else if(returnType.equals("java.lang.Double")){
return new DDIV();
}else if(returnType.equals("java.lang.Float")){
return new FDIV();
}else if(returnType.equals("java.lang.Long")){
return new LDIV();
}else{
throw new NotImplementedException();
}
}
}
// ino.end

21
src/de/dhbwstuttgart/syntaxtree/operator/EqualOp.java
View File

@ -3,10 +3,22 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.end
// ino.module.EqualOp.8597.import
import java.util.Iterator;
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.Constants;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.GOTO;
import org.apache.commons.bcel6.generic.IF_ICMPNE;
import org.apache.commons.bcel6.generic.InstructionConstants;
import org.apache.commons.bcel6.generic.InstructionList;
import org.apache.commons.bcel6.generic.NOP;
import org.apache.commons.bcel6.generic.ObjectType;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.parser.JavaClassName;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Expr;
@ -14,6 +26,8 @@ import de.dhbwstuttgart.syntaxtree.statement.Null;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.unify.TypeUnify;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
@ -31,6 +45,11 @@ public class EqualOp extends RelOp
super(offset, variableLength);
}
// ino.end
@Override
BranchInstruction getOperator() {
return new IF_ICMPNE(null);
}
}
// ino.end

8
src/de/dhbwstuttgart/syntaxtree/operator/GreaterEquOp.java
View File

@ -4,6 +4,9 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.module.GreaterEquOp.8598.import
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.IF_ICMPLT;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
@ -25,6 +28,11 @@ public class GreaterEquOp extends RelOp
super(offset,variableLength);
}
// ino.end
@Override
BranchInstruction getOperator() {
return new IF_ICMPLT(null);
}
}
// ino.end

8
src/de/dhbwstuttgart/syntaxtree/operator/GreaterOp.java
View File

@ -4,6 +4,9 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.module.GreaterOp.8599.import
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.IF_ICMPLE;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Expr;
@ -25,5 +28,10 @@ public class GreaterOp extends RelOp
}
// ino.end
@Override
BranchInstruction getOperator() {
return new IF_ICMPLE(null);
}
}
// ino.end

8
src/de/dhbwstuttgart/syntaxtree/operator/LessEquOp.java
View File

@ -4,6 +4,9 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.module.LessEquOp.8600.import
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.IF_ICMPGT;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Expr;
@ -25,5 +28,10 @@ public class LessEquOp extends RelOp
}
// ino.end
@Override
BranchInstruction getOperator() {
return new IF_ICMPGT(null);
}
}
// ino.end

7
src/de/dhbwstuttgart/syntaxtree/operator/LessOp.java
View File

@ -3,6 +3,8 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.end
// ino.module.LessOp.8601.import
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.IF_ICMPGE;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
@ -25,5 +27,10 @@ public class LessOp extends RelOp
}
// ino.end
@Override
BranchInstruction getOperator() {
return new IF_ICMPGE(null);
}
}
// ino.end

8
src/de/dhbwstuttgart/syntaxtree/operator/MinusOp.java
View File

@ -4,6 +4,10 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.module.MinusOp.8603.import
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.generic.ArithmeticInstruction;
import org.apache.commons.bcel6.generic.IADD;
import org.apache.commons.bcel6.generic.ISUB;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Expr;
@ -25,6 +29,8 @@ public class MinusOp extends AddOp
}
// ino.end
ArithmeticInstruction getOperator(String returnType) {
return new ISUB();
}
}
// ino.end

8
src/de/dhbwstuttgart/syntaxtree/operator/ModuloOp.java
View File

@ -4,6 +4,9 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.module.ModuloOp.8604.import
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.generic.ArithmeticInstruction;
import org.apache.commons.bcel6.generic.IREM;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Expr;
@ -25,5 +28,10 @@ public class ModuloOp extends MulOp
}
// ino.end
@Override
ArithmeticInstruction getOperator(String returnType) {
return new IREM();
}
}
// ino.end

74
src/de/dhbwstuttgart/syntaxtree/operator/MulOp.java
View File

@ -6,16 +6,30 @@ package de.dhbwstuttgart.syntaxtree.operator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.Constants;
import org.apache.commons.bcel6.generic.ArithmeticInstruction;
import org.apache.commons.bcel6.generic.InstructionList;
import org.apache.commons.bcel6.generic.InvokeInstruction;
import org.apache.commons.bcel6.generic.ObjectType;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Expr;
import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
import de.dhbwstuttgart.typeinference.unify.TypeUnify;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
// ino.class.MulOp.24231.declaration
public abstract class MulOp extends Operator
@ -50,6 +64,62 @@ public abstract class MulOp extends Operator
return ret;
}
@Override
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator) {
// TODO Plus Operator ist bis jetzt nur für Integer implementiert
/*
0: aload_1
1: invokevirtual #2 // Method java/lang/Integer.intValue:()I
4: aload_1
5: invokevirtual #2 // Method java/lang/Integer.intValue:()I
8: imul
9: invokestatic #3 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
12: areturn
*/
DHBWInstructionFactory _factory = _cg.getInstructionFactory();
String returnType = getReturnType(operator.get_Expr1(), operator.get_Expr2(), rs);
InstructionList il = getInstructionListForOperand(_cg, rs, operator.get_Expr1(), returnType);
il.append(getInstructionListForOperand(_cg, rs, operator.get_Expr2(), returnType));
il.append(getOperator(returnType));
il.append(convertValueToObject(_factory, returnType));
return il;
}
private String getReturnType(Expr expr1, Expr expr2, TypeinferenceResultSet rs) {
Type type = expr1.getType();
if(type instanceof TypePlaceholder){
Type tphType = rs.getTypeOfPlaceholder((TypePlaceholder) expr1.getType());
if(tphType instanceof ExtendsWildcardType){
return ((ExtendsWildcardType) tphType).get_ExtendsType().get_Name();
}else if(tphType instanceof SuperWildcardType){
return ((SuperWildcardType) tphType).get_SuperType().get_Name();
}else{
return tphType.getName().toString();
}
}else{
return type.get_Name();
}
}
abstract ArithmeticInstruction getOperator(String returnType);
private InvokeInstruction convertValueToObject(DHBWInstructionFactory _factory, String returnType) {
if(returnType.equals("java.lang.Integer")){
return _factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.INT}, Constants.INVOKESTATIC);
}else if(returnType.equals("java.lang.Double")){
return _factory.createInvoke("java.lang.Double", "valueOf", new ObjectType("java.lang.Double"), new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.DOUBLE}, Constants.INVOKESTATIC);
}else if(returnType.equals("java.lang.Float")){
return _factory.createInvoke("java.lang.Float", "valueOf", new ObjectType("java.lang.Float"), new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.FLOAT}, Constants.INVOKESTATIC);
}else if(returnType.equals("java.lang.Long")){
return _factory.createInvoke("java.lang.Long", "valueOf", new ObjectType("java.lang.Long"), new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.LONG}, Constants.INVOKESTATIC);
}else{
throw new NotImplementedException();
}
}
}
// ino.end

9
src/de/dhbwstuttgart/syntaxtree/operator/NotEqualOp.java
View File

@ -3,7 +3,6 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.end
// ino.module.NotEqualOp.8606.import
import java.util.Iterator;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.myexception.JVMCodeException;
@ -13,6 +12,9 @@ import de.dhbwstuttgart.syntaxtree.statement.Null;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.unify.TypeUnify;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.IF_ACMPEQ;
// ino.class.NotEqualOp.24241.declaration
public class NotEqualOp extends RelOp
@ -28,5 +30,10 @@ public class NotEqualOp extends RelOp
}
// ino.end
@Override
BranchInstruction getOperator() {
return new IF_ACMPEQ(null);
}
}
// ino.end

34
src/de/dhbwstuttgart/syntaxtree/operator/Operator.java
View File

@ -5,8 +5,16 @@ package de.dhbwstuttgart.syntaxtree.operator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.Constants;
import org.apache.commons.bcel6.generic.DADD;
import org.apache.commons.bcel6.generic.FADD;
import org.apache.commons.bcel6.generic.IADD;
import org.apache.commons.bcel6.generic.InstructionList;
import org.apache.commons.bcel6.generic.LADD;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.core.IItemWithOffset;
import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.myexception.JVMCodeException;
@ -19,8 +27,10 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.OderConstraint;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.UndConstraint;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
import de.dhbwstuttgart.typeinference.unify.TypeUnify;
@ -63,11 +73,33 @@ public abstract class Operator extends SyntaxTreeNode
* @return
*/
public abstract HashMap<Type,Type> getReturnTypes(TypeAssumptions ass);
public abstract InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator);
@Override
public Menge<SyntaxTreeNode> getChildren() {
return new Menge<>();
}
protected InstructionList getInstructionListForOperand(ClassGenerator _cg, TypeinferenceResultSet rs, Expr operand, String returnType){
InstructionList il = new InstructionList();
il.append(operand.genByteCode(_cg, rs));
if(returnType.equals("java.lang.Integer")){
il.append(_cg.getInstructionFactory().createInvoke("java.lang.Integer", "intValue", org.apache.commons.bcel6.generic.Type.INT, new org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
}else if(returnType.equals("java.lang.Double")){
il.append(_cg.getInstructionFactory().createInvoke("java.lang.Double", "doubleValue", org.apache.commons.bcel6.generic.Type.DOUBLE, new org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
}else if(returnType.equals("java.lang.Float")){
il.append(_cg.getInstructionFactory().createInvoke("java.lang.Float", "floatValue", org.apache.commons.bcel6.generic.Type.FLOAT, new org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
}else if(returnType.equals("java.lang.Long")){
il.append(_cg.getInstructionFactory().createInvoke("java.lang.Long", "longValue", org.apache.commons.bcel6.generic.Type.LONG, new org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
}else if(returnType.equals("java.lang.String")){
}else{
throw new NotImplementedException(returnType);
}
return il;
}
}
// ino.end

54
src/de/dhbwstuttgart/syntaxtree/operator/OrOp.java
View File

@ -2,6 +2,19 @@
package de.dhbwstuttgart.syntaxtree.operator;
// ino.end
import org.apache.commons.bcel6.Constants;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.GOTO;
import org.apache.commons.bcel6.generic.IFEQ;
import org.apache.commons.bcel6.generic.IFNE;
import org.apache.commons.bcel6.generic.InstructionConstants;
import org.apache.commons.bcel6.generic.InstructionList;
import org.apache.commons.bcel6.generic.ObjectType;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
// ino.class.OrOp.24282.declaration
public class OrOp extends LogOp
@ -17,6 +30,47 @@ public class OrOp extends LogOp
super(offset,variableLength);
}
// ino.end
@Override
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator) {
/*
0: aload_1
1: invokevirtual #2 // Method java/lang/Boolean.booleanValue:()Z
4: ifne 14
7: aload_2
8: invokevirtual #2 // Method java/lang/Boolean.booleanValue:()Z
11: ifeq 18
14: iconst_1
15: goto 19
18: iconst_0
19: invokestatic #3 // Method java/lang/Boolean.valueOf:(Z)Ljava/lang/Boolean;
22: areturn
*/
DHBWInstructionFactory _factory = _cg.getInstructionFactory();
InstructionList il = operator.get_Expr1().genByteCode(_cg, rs);
il.append(_factory.createInvoke("java.lang.Boolean", "booleanValue", org.apache.commons.bcel6.generic.Type.BOOLEAN, new org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
BranchInstruction firstTest = new IFNE(null);
il.append(firstTest);
il.append(operator.get_Expr2().genByteCode(_cg, rs));
il.append(_factory.createInvoke("java.lang.Boolean", "booleanValue", org.apache.commons.bcel6.generic.Type.BOOLEAN, new org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
BranchInstruction secondTest = new IFEQ(null);
il.append(secondTest);
firstTest.setTarget(il.append(InstructionConstants.ICONST_1));
BranchInstruction gotoInstruction = new GOTO(null);
il.append(gotoInstruction);
secondTest.setTarget(il.append(InstructionConstants.ICONST_0));
gotoInstruction.setTarget(il.append(_factory.createInvoke("java.lang.Boolean", "valueOf", new ObjectType("java.lang.Boolean"), new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.BOOLEAN}, Constants.INVOKESTATIC)));
return il;
}
}
// ino.end

35
src/de/dhbwstuttgart/syntaxtree/operator/PlusOp.java
View File

@ -3,10 +3,30 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.end
// ino.module.PlusOp.8609.import
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
import org.apache.commons.bcel6.Constants;
import org.apache.commons.bcel6.generic.ArithmeticInstruction;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.DADD;
import org.apache.commons.bcel6.generic.FADD;
import org.apache.commons.bcel6.generic.GOTO;
import org.apache.commons.bcel6.generic.IADD;
import org.apache.commons.bcel6.generic.IFEQ;
import org.apache.commons.bcel6.generic.IFNE;
import org.apache.commons.bcel6.generic.InstructionConstants;
import org.apache.commons.bcel6.generic.InstructionList;
import org.apache.commons.bcel6.generic.InvokeInstruction;
import org.apache.commons.bcel6.generic.LADD;
import org.apache.commons.bcel6.generic.ObjectType;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Expr;
import de.dhbwstuttgart.syntaxtree.type.Type;
@ -24,6 +44,19 @@ public class PlusOp extends AddOp
super(offset,variableLength);
}
// ino.end
ArithmeticInstruction getOperator(String returnType) {
if(returnType.equals("java.lang.Integer")){
return new IADD();
}else if(returnType.equals("java.lang.Double")){
return new DADD();
}else if(returnType.equals("java.lang.Float")){
return new FADD();
}else if(returnType.equals("java.lang.Long")){
return new LADD();
}else{
throw new NotImplementedException();
}
}
}
// ino.end

51
src/de/dhbwstuttgart/syntaxtree/operator/RelOp.java
View File

@ -6,14 +6,24 @@ package de.dhbwstuttgart.syntaxtree.operator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.Constants;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.GOTO;
import org.apache.commons.bcel6.generic.InstructionConstants;
import org.apache.commons.bcel6.generic.InstructionList;
import org.apache.commons.bcel6.generic.ObjectType;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
import de.dhbwstuttgart.typeinference.unify.TypeUnify;
@ -54,6 +64,45 @@ public abstract class RelOp extends Operator
return ret;
}
@Override
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator) {
/*
0: aload_1
1: invokevirtual #3 // Method java/lang/Integer.intValue:()I
4: aload_2
5: invokevirtual #3 // Method java/lang/Integer.intValue:()I
8: if_icmplt 15
11: iconst_1
12: goto 16
15: iconst_0
16: invokestatic #2 // Method java/lang/Boolean.valueOf:(Z)Ljava/lang/Boolean;
19: areturn
*/
DHBWInstructionFactory _factory = _cg.getInstructionFactory();
InstructionList il = getInstructionListForOperand(_cg, rs, operator.get_Expr1(), "java.lang.Boolean");
il.append(getInstructionListForOperand(_cg, rs, operator.get_Expr2(), "java.lang.Boolean"));
BranchInstruction operatorBranchInstruction = getOperator();
il.append(operatorBranchInstruction);
il.append(InstructionConstants.ICONST_1);
BranchInstruction gotoInstruction = new GOTO(null);
il.append(gotoInstruction);
operatorBranchInstruction.setTarget(il.append(InstructionConstants.ICONST_0));
gotoInstruction.setTarget(il.append(_factory.createInvoke("java.lang.Boolean", "valueOf", new ObjectType("java.lang.Boolean"), new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.BOOLEAN}, Constants.INVOKESTATIC)));
return il;
}
abstract BranchInstruction getOperator();
}
// ino.end

21
src/de/dhbwstuttgart/syntaxtree/operator/TimesOp.java
View File

@ -4,6 +4,13 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.module.TimesOp.8611.import
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
import org.apache.commons.bcel6.generic.ArithmeticInstruction;
import org.apache.commons.bcel6.generic.DMUL;
import org.apache.commons.bcel6.generic.FMUL;
import org.apache.commons.bcel6.generic.IMUL;
import org.apache.commons.bcel6.generic.LMUL;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
@ -22,6 +29,20 @@ public class TimesOp extends MulOp
super(offset,variableLength);
}
// ino.end
ArithmeticInstruction getOperator(String returnType) {
if(returnType.equals("java.lang.Integer")){
return new IMUL();
}else if(returnType.equals("java.lang.Double")){
return new DMUL();
}else if(returnType.equals("java.lang.Float")){
return new FMUL();
}else if(returnType.equals("java.lang.Long")){
return new LMUL();
}else{
throw new NotImplementedException();
}
}
}
// ino.end

2
src/de/dhbwstuttgart/syntaxtree/statement/Assign.java
View File

@ -207,7 +207,7 @@ public class Assign extends Expr
}
*/
//Es wird momentan immer von RefType ausgegangen:
il.append(new ASTORE(_factory.getStoreIndex(expr1.get_Name())));
il.append(_factory.createStore(expr2.getType().getBytecodeType(cg, rs), expr1.get_Name()));
return il;
}

22
src/de/dhbwstuttgart/syntaxtree/statement/Binary.java
View File

@ -227,27 +227,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
@Override
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
InstructionList linkeSeite = this.expr1.genByteCode(_cg, rs);
InstructionList rechteSeite = this.expr2.genByteCode(_cg, rs);
if(this.getReturnType().getName().equals(new JavaClassName("String"))){
throw new TypeinferenceException("Zeichenketten zusammenfügen ist noch nicht unterstützt",this);
}
linkeSeite.append(rechteSeite);
//TODO: bytecode (Bis jetzt wird jeder Condition als EQUALS behandelt)
//TODO: bytecode autoboxing
BranchInstruction if_icmpneInstruction = new IF_ICMPNE(null);
linkeSeite.append(if_icmpneInstruction);
linkeSeite.append(InstructionConstants.ICONST_1);
BranchInstruction gotoInstruction = new GOTO(null);
linkeSeite.append(gotoInstruction);
if_icmpneInstruction.setTarget(linkeSeite.append(InstructionConstants.ICONST_0));
gotoInstruction.setTarget(linkeSeite.append(new NOP()));
return linkeSeite;
return op.genByteCode(_cg, rs, this);
}
}

4
src/de/dhbwstuttgart/syntaxtree/statement/ForStmt.java
View File

@ -38,10 +38,6 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
import de.dhbwstuttgart.typeinference.unify.TypeUnify;
public class ForStmt extends Statement
{

33
src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java
View File

@ -164,38 +164,13 @@ public class LambdaExpression extends Expr{
ret.add(method_body.TYPEStmt(ArgumentAssumptions.add(assumptions))); //Es gibt die LambdaExpression nur mit einem Block als Method Body, nicht mit einer einzelnen Expression
//Die Constraints für ParameterTypen und Ret Typ erstellen:
Menge<Type> modifiedParamTypes = new Menge<>();
for(Type pT : paramTypes){
if(pT instanceof WildcardType){
//Auf Typfehler kontrollieren. Siehe Bug #12 Kommentar 3
if(pT instanceof ExtendsWildcardType){
throw new TypeinferenceException("Typfehler von Parametertyp "+pT,this);
}else{
modifiedParamTypes.add(pT);
}
}else{
modifiedParamTypes.add(new SuperWildcardType((ObjectType) pT));
}
}
Type retType = method_body.getType();
// PN < TPH PN
if(retType instanceof WildcardType){
//Auf Typfehler kontrollieren. Siehe Bug #12 Kommentar 3
if(retType instanceof SuperWildcardType){
throw new TypeinferenceException("Typfehler von Parametertyp "+retType,this);
}else{
//retType bleibt unverändert
}
}else{
//Die LambdaExpression kann zu diesem Zeit schon feststellen, ob der Return-Type Void ist (Kein Return-Statement):
if(!typeIsVoid(retType)){ //Nur, wenn es nicht void ist, kann der ExtendsWildcardType gebildet werden.
retType = new ExtendsWildcardType((ObjectType) retType);
}
}
if(typeIsVoid(retType)){//In diesem Fall, muss der Typ des LambdaAusdrucks FunVoid sein
this.lambdaType = new FunVoidN(modifiedParamTypes);
this.lambdaType = new FunVoidN(paramTypes);
}else{
this.lambdaType = new FunN(retType, modifiedParamTypes);
this.lambdaType = new FunN(retType, paramTypes);
}
ret.add(ConstraintsSet.createSingleConstraint(lambdaType.TYPE(assumptions, this),this.getType().TYPE(assumptions, this)));

55
src/de/dhbwstuttgart/syntaxtree/statement/LocalVarDecl.java
View File

@ -99,59 +99,6 @@ public class LocalVarDecl extends Statement implements TypeInsertable
}
// ino.end
// ino.method.is_declared.25587.definition
public void is_declared(Type t, Menge<Class> classlist)
throws SCStatementException
// ino.end
// ino.method.is_declared.25587.body
{
boolean flag=false;
for(Enumeration<Class> e = classlist.elements();e.hasMoreElements();){
flag = false;
Class c = e.nextElement();
// System.out.println("is_init: vergleiche "+t.get_Type_()+" mit "+c.get_classname());
if(c.getName().equals(t.getName())){
// System.out.println("Klasse "+t.get_Type()+" im Menge classlist gefunden.");
flag = true;
break;
}
}
if ( t instanceof RefType )
{
if(((RefType)t).get_ParaList()!=null)
{
if( ((RefType)t).get_ParaList().size()>0)
{
for(Enumeration e1 = ((RefType)t).get_ParaList().elements();e1.hasMoreElements();)
{
try
{
is_declared((Type)e1.nextElement(),classlist);
}
catch(SCStatementException ex)
{
throw ex;
}
}
}
}
}
if(!flag)
{
SCStatementException ex = new SCStatementException();
SCExcept e = new SCExcept();
e.set_error("unbekannte Klasse "+t.getName()+".");
e.set_function("complete_parahashtable() --> is_declared()");
e.set_statement(t.getName().toString());
ex.addException(e);
throw ex;
}
}
// ino.end
/*
// ino.method.check_anz.25590.definition
public void check_anz(Type type, Menge paralist, Menge<Class> classlist)
@ -429,7 +376,7 @@ public class LocalVarDecl extends Statement implements TypeInsertable
@Override
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
// TODO Auto-generated method stub
_cg.getInstructionFactory().getStoreIndex(get_Name());
return new InstructionList();
}
}

1
src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java
View File

@ -326,6 +326,7 @@ public class MethodCall extends Expr
public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
InstructionList il = new InstructionList();
DHBWInstructionFactory _factory = cg.getInstructionFactory();
//TODO: später wiederherstelln?
_factory.resetStoreIndexes();
il.append(receiver.get_Expr().genByteCode(cg, rs));

20
src/de/dhbwstuttgart/syntaxtree/statement/WhileStmt.java
View File

@ -6,7 +6,11 @@ import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.ClassGen;
import org.apache.commons.bcel6.generic.DUP;
import org.apache.commons.bcel6.generic.GOTO;
import org.apache.commons.bcel6.generic.IFEQ;
import org.apache.commons.bcel6.generic.InstructionList;
import de.dhbwstuttgart.typeinference.Menge;
@ -138,8 +142,20 @@ public class WhileStmt extends Statement
@Override
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
// TODO Bytecode
throw new NotImplementedException();
//TOD: while Statement
InstructionList il = expr.genByteCode(_cg, rs);
BranchInstruction ifeq = new IFEQ(null);
il.append(ifeq);
il.append(loop_block.genByteCode(_cg, rs));
il.append(new GOTO(il.getStart()));
ifeq.setTarget(il.append(new DUP()));
return il;
}
}
// ino.end

48
src/de/dhbwstuttgart/syntaxtree/type/FunN.java
View File

@ -1,15 +1,21 @@
package de.dhbwstuttgart.syntaxtree.type;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.parser.JavaClassName;
import de.dhbwstuttgart.syntaxtree.Method;
import de.dhbwstuttgart.syntaxtree.ParameterList;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
/**
* @see Spezifikation "Complete Typeinference in Java 8" von Martin Plümicke
@ -23,7 +29,7 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
public class FunN extends RefType {
private Type R;
private Menge<Type> T;
private List<? extends Type> T;
/**
* @author Andreas Stadelmeier, a10023
@ -33,7 +39,7 @@ public class FunN extends RefType {
* @param T
* @return
*/
public FunN(Type R, Menge<Type> T) {
public FunN(Type R, List<? extends Type> T) {
super("",null,0);
if(T==null || R == null)throw new NullPointerException();
setT(T);
@ -44,11 +50,11 @@ public class FunN extends RefType {
/**
* Spezieller Konstruktor um eine FunN ohne Returntype zu generieren
*/
protected FunN(Menge<Type> T){
protected FunN(List<? extends Type> list){
super("",null,0);
if(T==null)throw new NullPointerException();
setT(T);
this.name = new JavaClassName("Fun"+T.size());//getName();
if(list==null)throw new NullPointerException();
setT(list);
this.name = new JavaClassName("Fun"+list.size());//getName();
}
/**
@ -68,15 +74,6 @@ public class FunN extends RefType {
setT(t);
this.name = new JavaClassName("Fun"+parameterCount);
/*
Menge<Type> t = new Menge<Type>();
for(int i=0;i<parameterCount;i++){
t.add(TypePlaceholder.fresh(this));
}
R = TypePlaceholder.fresh(this);
T = t;
this.name = getName();
*/
}
/**
@ -87,11 +84,16 @@ public class FunN extends RefType {
Menge<Type> t = new Menge<Type>();
if(R!=null)t.add(R);
if(T!=null)t.addAll(T);
for(Type type : t){
if(type instanceof WildcardType){
throw new DebugException("Der FunN-Typ darf keine Wildcards in den Parameter enthalten");
}
}
this.set_ParaList(t);
}
protected void setT(Menge<Type> T){
this.T = T;
protected void setT(List<? extends Type> list){
this.T = list;
calculateNewParalist();
}
protected void setR(Type R){
@ -137,6 +139,18 @@ public class FunN extends RefType {
return ret;
}
@Override
public Type TYPE(TypeAssumptions ass, SyntaxTreeNode parent){
//FunN Typen müssen nicht geprüft werden. Sie werden schließlich nur von unserem Typinferenzalgorithmus erstellt:
List<Type> paraList = new ArrayList<>();
for(Type t : this.T){
Type toAdd = t.TYPE(ass, parent);
//if(toAdd == null)throw new TypeinferenceException("Typ "+toAdd+" ist in den Assumptions nicht vorhanden",this);
paraList.add(toAdd);
}
FunN ret = new FunN(this.R.TYPE(ass, parent),paraList);
return ret;
}
/*
public CMethodTypeAssumption toCMethodTypeAssumption() {

4
src/de/dhbwstuttgart/syntaxtree/type/GenericClassType.java
View File

@ -1,5 +1,7 @@
package de.dhbwstuttgart.syntaxtree.type;
import java.util.List;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.parser.JavaClassName;
import de.dhbwstuttgart.syntaxtree.Class;
@ -12,7 +14,7 @@ import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
public class GenericClassType extends RefType{
public GenericClassType(String fullyQualifiedName, Menge parameter, SyntaxTreeNode parent, int offset) {
public GenericClassType(String fullyQualifiedName, List parameter, SyntaxTreeNode parent, int offset) {
super(fullyQualifiedName, parameter, parent, offset);
}

241
src/de/dhbwstuttgart/syntaxtree/type/RefType.java
View File

@ -6,6 +6,7 @@ import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.logger.Logger;
@ -47,7 +48,7 @@ public class RefType extends ObjectType implements IMatchable
private boolean IsArray = false;
// ino.attribute.parameter.26625.declaration
private Menge<Type> parameter = null;
private List<Type> parameter = null;
// ino.end
// ino.attribute.primitiveFlag.29412.decldescription type=javadoc
/**
@ -97,7 +98,7 @@ public class RefType extends ObjectType implements IMatchable
}
// ino.method.RefType.26640.definition
public RefType(String fullyQualifiedName, Menge parameter,SyntaxTreeNode parent, int offset)
public RefType(String fullyQualifiedName, List parameter,SyntaxTreeNode parent, int offset)
// ino.end
// ino.method.RefType.26640.body
{
@ -134,52 +135,6 @@ public class RefType extends ObjectType implements IMatchable
this(jName.toString(), parent, offset);
}
// ino.method.Type2Key.26646.definition
public String Type2Key()
// ino.end
// ino.method.Type2Key.26646.body
{
if(parameter==null)
{
return name.toString();
}
else
{
String para = new String();
for(Enumeration e=parameter.elements();e.hasMoreElements();)
{
String t = ((Type)e.nextElement()).Type2Key();
if(para.length() > 0)
para = para +", "+ t;
else para = " " + t;
}
return name + "<"+para + " >" ;
}
}
// ino.end
// ino.method.Type2String.26649.definition
public String Type2String()
// ino.end
// ino.method.Type2String.26649.body
{
if(parameter==null)
{
return name.toString();
}
else
{
String para = new String();
for(Enumeration e=parameter.elements();e.hasMoreElements();)
{
String t = ((Type)e.nextElement()).Type2String();
if(para.length() > 0)
para = para +", "+ t;
else para = " " + t;
}
return name + "<"+para + " >" ;
}
}
/**
* Wandelt die Parameter des RefTypes in TPHs um, sofern es sich um Generische Variablen handelt.
@ -290,7 +245,7 @@ public class RefType extends ObjectType implements IMatchable
* @param v
*/
// ino.method.set_ParaList.26661.definition
public void set_ParaList(Menge<Type> v)
public void set_ParaList(List<Type> v)
// ino.end
// ino.method.set_ParaList.26661.body
{
@ -301,8 +256,6 @@ public class RefType extends ObjectType implements IMatchable
else paralist.add(t);
}*/
this.parameter = v;//paralist;
//parserlog.debug("T->Type.java->set_ParaList->parameter: " + parameter);
//parserlog.debug("T->Type.java->get_Type: " + getName());
}
// ino.end
@ -310,7 +263,7 @@ public class RefType extends ObjectType implements IMatchable
* @return gibt bei leere Parameterliste null zurück. Ist entscheidend für unify-Algorithmus
*/
// ino.method.get_ParaList.26664.definition
public Menge<Type> get_ParaList()
public List<Type> get_ParaList()
// ino.end
// ino.method.get_ParaList.26664.body
{
@ -319,7 +272,7 @@ public class RefType extends ObjectType implements IMatchable
}
// ino.end
public Menge<Type> getParaList(){
public List<Type> getParaList(){
if(this.parameter==null)return new Menge<>();
return this.parameter;
}
@ -341,179 +294,7 @@ public class RefType extends ObjectType implements IMatchable
// otth: Liefert den Namen des Typs, ohne Parameter, z.B. Stapel bei Stapel<IntZahl>
return name.toString();
}
// ino.end
// ino.method.getParaN.26673.definition
public String getParaN( int n )
throws SCException
// ino.end
// ino.method.getParaN.26673.body
{
// otth: liefert n.ten Parameter
if( parameter == null )
{
throw new SCException();
}
if( n >= parameter.size() )
return "";
return ((Type)parameter.elementAt(n)).getName().toString();
}
// ino.end
// ino.method.isTV.26676.definition
public boolean isTV( int n )
// ino.end
// ino.method.isTV.26676.body
{
// otth: Prueft, ob Parameter n eine TV ist
return parameter.elementAt(n) instanceof TypePlaceholder;
}
// ino.end
// ino.method.is_Equiv.26679.defdescription type=line
// GenericTypeVar ergaenzt PL 06-03-16
// ino.end
// ino.method.is_Equiv.26679.definition
public boolean is_Equiv(RefType ty2, Hashtable<JavaClassName,Type> ht)
// ino.end
// ino.method.is_Equiv.26679.body
{
//vergleicht einen Typ ty2 mit dem aktuellen Typ, ob es bis auf Variablenumbennung
//gleich ist.
//System.out.println("is_EquivSTART: " + this.get_Type());
//System.out.println("is_EquivSTART: " + ty2.get_Type());
if (this.getTypeName().equals(ty2.getTypeName())) {
//System.out.println("is_EquivSTARTx: " + this.get_Type());
if ((get_ParaList() != null) && (ty2.get_ParaList() != null)) {
if (get_ParaList().size() == ty2.get_ParaList().size()) {
for(int i=0; i < get_ParaList().size(); i++) {
Type pty1 = (Type)get_ParaList().elementAt(i);
Type pty2 = (Type)ty2.get_ParaList().elementAt(i);
if ((pty1 instanceof RefType) && (pty2 instanceof RefType)) {
//System.out.println("Instance RefType" + ((RefType)pty1).get_Type());
//System.out.println("Instance RefType" + ((RefType)pty2).get_Type());
if (!((RefType)pty1).is_Equiv((RefType)pty2, ht)) return false;
}
else {
if ((pty1 instanceof TypePlaceholder) && (pty2 instanceof TypePlaceholder)) {
//System.out.println("Instance TypePlaceholder" + (((TypePlaceholder)pty1).get_Type()));
//System.out.println("Instance TypePlaceholder" + (((TypePlaceholder)pty2).get_Type()));
if (ht.get((((TypePlaceholder)pty1).getName())) != null) {
//System.out.println(ht.get((((TypePlaceholder)pty1).getName())));
if (!((TypePlaceholder)ht.get((((TypePlaceholder)pty1).getName()))).getName().equals(pty2.getName())) return false;
}
else {
//System.out.println("INPUT" + pty1.getName());
//System.out.println("INPUT" + pty2);
ht.put(pty1.getName(), pty2);
}
}
else {
if ((pty1 instanceof GenericTypeVar) && (pty2 instanceof GenericTypeVar)) {
if (ht.get((((GenericTypeVar)pty1).getName())) != null) {
if (!((GenericTypeVar)ht.get((((GenericTypeVar)pty1).getName()))).getName().equals(pty2.getName())) return false;
}
else {
ht.put(pty1.getName(), pty2);
}
}
else {
return false;
}
}
}
}
return true;
}
else {
return false;
}
}
else {
//Typ ohne Parameter
return true;
}
}
else {
return false;
}
}
// ino.end
// ino.method.Equiv2Equal.26682.definition
public boolean Equiv2Equal(RefType ty2, Hashtable<JavaClassName,Type> ht)
// ino.end
// ino.method.Equiv2Equal.26682.body
{
//vergleicht einen Typ ty2 mit dem aktuellen Typ, ob er bis auf Variablenumbennung
//gleich ist und bennent ty2 so um, dass sie gleich sind.
//System.out.println("is_EquivSTART: " + this.getName());
//System.out.println("is_EquivSTART: " + ty2.getName());
if (this.getTypeName().equals(ty2.getTypeName())) {
//System.out.println("is_EquivSTARTx: " + this.getName());
if ((get_ParaList() != null) && (ty2.get_ParaList() != null)) {
if (get_ParaList().size() == ty2.get_ParaList().size()) {
for(int i=0; i < get_ParaList().size(); i++) {
Type pty1 = (Type)get_ParaList().elementAt(i);
Type pty2 = (Type)ty2.get_ParaList().elementAt(i);
if ((pty1 instanceof RefType) && (pty2 instanceof RefType)) {
//System.out.println("Instance RefType" + ((RefType)pty1).getName());
//System.out.println("Instance RefType" + ((RefType)pty2).getName());
if (!((RefType)pty1).is_Equiv((RefType)pty2, ht)) return false;
}
else {
if ((pty1 instanceof TypePlaceholder) && (pty2 instanceof TypePlaceholder)) {
//System.out.println("Instance TypePlaceholder" + (((TypePlaceholder)pty1).getName()));
//System.out.println("Instance TypePlaceholder" + (((TypePlaceholder)pty2).getName()));
if (ht.get((((TypePlaceholder)pty1).getName())) != null) {
//System.out.println(ht.get((((TypePlaceholder)pty1).getName())));
if (!((TypePlaceholder)ht.get((((TypePlaceholder)pty1).getName()))).getName().equals(pty2.getName())) return false;
else { //Typvariablen gleich machen
// #JB# 11.04.2005
// ###########################################################
((TypePlaceholder)pty2).backdoorSetName(((TypePlaceholder)ht.get((((TypePlaceholder)pty1).getName()))).getName().toString());
//pty2.setName(((TypePlaceholder)ht.get((((TypePlaceholder)pty1).getName()))).getName());
// ###########################################################
}
}
else {
//System.out.println("INPUT" + pty1.getName());
//System.out.println("INPUT" + pty2);
ht.put(pty1.getName(), pty2);
// #JB# 11.04.2005
// ###########################################################
((TypePlaceholder)pty2).backdoorSetName(pty1.getName().toString());
//pty2.setName(pty1.getName());
// ###########################################################
}
}
else {
return false;
}
}
}
return true;
}
else {
return false;
}
}
else {
//Typ ohne Parameter
return true;
}
}
else {
return false;
}
}
// ino.end
// ino.method.equals.26685.defdescription type=javadoc
/**
* Author: Jrg Buerle<br/>
* @param Object
@ -565,11 +346,11 @@ public class RefType extends ObjectType implements IMatchable
{
if(this.get_ParaList() != null )
{
Menge para = this.get_ParaList();
List para = this.get_ParaList();
Menge<Type> clonepara = new Menge<Type>();
for(int i = 0; i< para.size(); i++)
{
clonepara.addElement(((Type)para.elementAt(i)).clone());
clonepara.addElement(((Type)para.get(i)).clone());
}
RefType newRefType=new RefType(this.getTypeName(), clonepara,this.getParent(),getOffset());
newRefType.setPrimitiveFlag(this.getPrimitiveFlag());
@ -598,10 +379,10 @@ public class RefType extends ObjectType implements IMatchable
else
{
String para = new String();
Enumeration e=parameter.elements();
while(e.hasMoreElements())
Iterator<Type> e=parameter.iterator();
while(e.hasNext())
{
Type ty = (Type)e.nextElement();
Type ty = (Type)e.next();
String t = ty.toString();
if(para.length() > 0)
para = para +", "+ t;

13
src/de/dhbwstuttgart/typeinference/ConstraintsSet.java
View File

@ -71,19 +71,6 @@ public class ConstraintsSet extends UndMenge<Pair> implements Iterable<OderConst
});
}
*/
/**
* Aus dem ConstraintsSet [ u1, u2, ... (OderConstraint), ... uN ] werden alle
* UndConstraints, welche sich nicht innerhalb eines OderConstraints befinden, herausgefiltert
* @return [u1, ... , uN]
*/
private Vector<UndConstraint> filterUndConstraints() {
Vector<UndConstraint> ret = new Vector<>();
for(OderConstraint con : constraintsSet){
UndConstraint filtered = con.filterUndConstraints();
if(filtered != null)ret.add(filtered);
}
return ret;
}
public void add(UndConstraint singleConstraint) {
OderConstraint toAdd = new OderConstraint();

19
src/de/dhbwstuttgart/typeinference/FunNInterface.java
View File

@ -2,9 +2,14 @@ package de.dhbwstuttgart.typeinference;
import de.dhbwstuttgart.typeinference.Menge;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import de.dhbwstuttgart.parser.JavaClassName;
import de.dhbwstuttgart.syntaxtree.Class;
import de.dhbwstuttgart.syntaxtree.modifier.Modifiers;
import de.dhbwstuttgart.syntaxtree.type.FunN;
import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.Type;
@ -78,5 +83,19 @@ public class FunNInterface extends Class{
return new FunNMethod(this.get_ParaList());
//return new FunNMethod(this.get_ParaList().size()-1);
}
@Override
public RefType getType() {
List<? extends Type> paraList = this.get_ParaList();
Iterator<? extends Type> paraIter = paraList.iterator();
Type R = paraIter.next();
List<Type> paraListNew = new ArrayList<>();
while(paraIter.hasNext()){
paraListNew.add(paraIter.next());
}
return new FunN(R, paraListNew);
}
}

7
src/de/dhbwstuttgart/typeinference/FunNMethod.java
View File

@ -3,6 +3,9 @@ package de.dhbwstuttgart.typeinference;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.syntaxtree.FormalParameter;
import java.util.List;
import de.dhbwstuttgart.syntaxtree.Class;
import de.dhbwstuttgart.syntaxtree.Method;
import de.dhbwstuttgart.syntaxtree.ParameterList;
@ -16,10 +19,10 @@ public class FunNMethod extends Method{
*
* @param N - Anzahl der Parameter (Beispiel: Fun2<R, T1, T2>)
*/
public FunNMethod(Menge<? extends Type> paralist){
public FunNMethod(List<? extends Type> paralist){
super(0); //Hat keinen Offset, da nur theoretisch gedachte Methode
int N = paralist.size(); //In der paraliste ist der erste Parameter der Rückgabetyp
this.setType(paralist.firstElement());
this.setType(paralist.get(0));
this.set_DeclId(new DeclId("apply"));
ParameterList pl = new ParameterList();
Menge<FormalParameter> fpList = new Menge<FormalParameter>();

3
src/de/dhbwstuttgart/typeinference/FunVoidNMethod.java
View File

@ -1,6 +1,7 @@
package de.dhbwstuttgart.typeinference;
import de.dhbwstuttgart.typeinference.Menge;
import java.util.List;
import de.dhbwstuttgart.syntaxtree.type.Void;
import de.dhbwstuttgart.syntaxtree.FormalParameter;
@ -17,7 +18,7 @@ public class FunVoidNMethod extends Method{
*
* @param N - Anzahl der Parameter (Beispiel: Fun2<R, T1, T2>)
*/
public FunVoidNMethod(Menge<? extends Type> paralist, Class parent){
public FunVoidNMethod(List<? extends Type> paralist, Class parent){
super(0); //Hat keinen Offset, da nur theoretisch gedachte Methode
int N = paralist.size();
this.setType(new Void(this, -1));

4
src/de/dhbwstuttgart/typeinference/OderConstraint.java
View File

@ -59,7 +59,9 @@ public class OderConstraint extends OderMenge<Pair>{
* @param toAdd
*/
public void addConstraint(Pair toAdd){
oderConstraintPairs.add(new SingleConstraint(toAdd));
UndConstraint uCons = new UndConstraint();
uCons.addConstraint(toAdd);
oderConstraintPairs.add(uCons);
}
@Override

55
src/de/dhbwstuttgart/typeinference/Pair.java
View File

@ -9,6 +9,7 @@ import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Hashtable;
import java.util.List;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
@ -143,8 +144,8 @@ public class Pair implements Serializable, DeepCloneable
RefType RT1=(RefType)TA1;
RefType RT2=(RefType)TA2;
if(RT1.getTypeName().equals(RT2.getTypeName())){
Menge<Type> v1=RT1.get_ParaList();
Menge<Type> v2=RT2.get_ParaList();
List<Type> v1=RT1.get_ParaList();
List<Type> v2=RT2.get_ParaList();
if(v1==null && v2==null){
return true;
}else{
@ -155,8 +156,8 @@ public class Pair implements Serializable, DeepCloneable
return false;
}else{
for(int i=0;i<v1.size();i++){
Type t1=v1.elementAt(i);
Type t2=v2.elementAt(i);
Type t1=v1.get(i);
Type t2=v2.get(i);
if(((t1 instanceof GenericTypeVar) && (t2 instanceof GenericTypeVar ))){
// alles ok, egal was drin steht, denn das kann man so nicht nachvollz.
}else{
@ -257,52 +258,6 @@ public class Pair implements Serializable, DeepCloneable
}
// ino.end
// ino.method.Pair_isEquiv.26582.definition
public boolean Pair_isEquiv(Pair p)
// ino.end
// ino.method.Pair_isEquiv.26582.body
{
//vergleicht Paare mit Reftype's, bis auf Variablenumbennung
Hashtable<JavaClassName,Type> ht = new Hashtable<JavaClassName,Type>();
//System.out.println((((RefType)TA1).is_Equiv((RefType)p.TA1, ht)));
//System.out.println(((RefType)TA2).is_Equiv((RefType)p.TA2, ht));
//Typen boxen, da es sich um TypePlaceholder handeln koennte
Menge<Type> hilfsMenge1 = new Menge<Type>();
Menge<Type> hilfsMenge2 = new Menge<Type>();
hilfsMenge1.addElement(TA1);
hilfsMenge2.addElement(TA2);
Menge<Type> hilfsMenge3 = new Menge<Type>();
Menge<Type> hilfsMenge4 = new Menge<Type>();
hilfsMenge3.addElement(p.TA1);
hilfsMenge4.addElement(p.TA2);
//return (((RefType)TA1).is_Equiv((RefType)p.TA1, ht) && ((RefType)TA2).is_Equiv((RefType)p.TA2, ht));
return (new RefType("dummy", hilfsMenge3,null,-1)).is_Equiv(new RefType("dummy", hilfsMenge1,null,-1), ht) &&
(new RefType("dummy", hilfsMenge4,null,-1)).is_Equiv(new RefType("dummy", hilfsMenge2,null,-1), ht);
}
// ino.end
// ino.method.isInMenge.26585.definition
public boolean isInMenge( Menge<Pair> V )
// ino.end
// ino.method.isInMenge.26585.body
{
// otth: prueft, ob Paar in Vektor liegt
for( int i = 0; i < V.size(); i++ )
{
if( V.elementAt(i) instanceof Pair )
{
//if( this.toString().equals( ( (Pair)V.elementAt(i) ).toString() ) )
if(Pair_isEquiv(V.elementAt(i))) {
return true;
}
}
}
return false;
}
// ino.end
// ino.method.equals.26588.defdescription type=javadoc
/**
* <br/>Author: J�rg B�uerle

10
src/de/dhbwstuttgart/typeinference/TypeinferenceResults.java
View File

@ -1,5 +1,7 @@
package de.dhbwstuttgart.typeinference;
import java.util.List;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.Section;
@ -9,21 +11,21 @@ import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
public class TypeinferenceResults {
private Menge<TypeinferenceResultSet> typeReconstructions;
private List<TypeinferenceResultSet> typeReconstructions;
public TypeinferenceResults() {
typeReconstructions = new Menge<>();
}
public TypeinferenceResults(Menge<TypeinferenceResultSet> typeReconstructions) {
public TypeinferenceResults(List<TypeinferenceResultSet> typeReconstructions) {
this.typeReconstructions = typeReconstructions;
}
public Menge<TypeinferenceResultSet> getTypeReconstructions() {
public List<TypeinferenceResultSet> getTypeReconstructions() {
return typeReconstructions;
}
public Menge<TypeinferenceResultSet> getTypeReconstructions(Method method, ClassGenerator cg) {
public List<TypeinferenceResultSet> getTypeReconstructions(Method method, ClassGenerator cg) {
return typeReconstructions;
}
}

6
src/de/dhbwstuttgart/typeinference/UndConstraint.java
View File

@ -33,7 +33,11 @@ public class UndConstraint extends UndMenge<Pair> {
public void addConstraint(Type type, Type rT) {
Pair p = new Pair(type, rT);
this.set.add(new EinzelElement<Pair>(p));
addConstraint(p);
}
public void addConstraint(Pair toAdd){
this.set.add(new EinzelElement<Pair>(toAdd));
}
@Override

12
src/de/dhbwstuttgart/typeinference/assumptions/TypeAssumptions.java
View File

@ -257,18 +257,6 @@ public class TypeAssumptions {
* @return null, falls der Typ nicht vorhanden ist.
*/
public Type getTypeFor(Type t, SyntaxTreeNode inNode){
/*
if(t instanceof WildcardType){
WildcardType wt = (WildcardType)t;
Type innerType = wt.GetWildcardType();
innerType = getTypeFor(innerType, t).getType();
wt.SetWildcardType(innerType);
return new ConstraintType(wt);
}
if(t instanceof TypePlaceholder)
return new ConstraintType((TypePlaceholder)t); //Handelt es sich um einen TypePlaceholder kann dieser nicht in den Assumptions vorkommen.
*/
//Alle bekannten Klassen nach diesem Typ durchsuchen:
JavaClassName typName = t.getName();
for(ClassAssumption ass : this.classAssumptions){

6
src/de/dhbwstuttgart/typeinference/exceptions/NotImplementedException.java
View File

@ -1,5 +1,11 @@
package de.dhbwstuttgart.typeinference.exceptions;
public class NotImplementedException extends RuntimeException {
public NotImplementedException() {
}
public NotImplementedException(String string) {
super(string);
}
}

2
src/de/dhbwstuttgart/typeinference/unify/model/FunNType.java
View File

@ -14,7 +14,7 @@ public class FunNType extends UnifyType {
* Creates a FunN-Type with the specified TypeParameters.
*/
protected FunNType(TypeParams p) {
super("FuN", p);
super("Fun"+(p.size()-1), p);
}
/**

8
test/bytecode/ASTBytecodeTest.java
View File

@ -56,10 +56,7 @@ public abstract class ASTBytecodeTest {
String rootDirectory = getRootDirectory();
System.out.println(rootDirectory);
JavaClass javaClass = result.getByteCode().getJavaClass();
System.out.println(javaClass.toString());
javaClass.dump(new File(rootDirectory+javaClass.getClassName()+".class"));
for(ClassGenerator cg: result.getByteCode().getExtraClasses().values()){
@ -68,7 +65,6 @@ public abstract class ASTBytecodeTest {
}
}catch(Exception e){
System.out.print(e.getMessage());
throw new RuntimeException(e);
}
}
@ -91,8 +87,4 @@ public abstract class ASTBytecodeTest {
public String getTestName() {
return "No Testname defined!";
}
}

21
test/bytecode/AssignTest.java
View File

@ -20,15 +20,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class AssignTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "Assign.jav";
public final static String outputFile = "Assign.class";
public class AssignTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "Assign";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

23
test/bytecode/BinaryTest.java
View File

@ -20,15 +20,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class BinaryTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "Binary.jav";
public final static String outputFile = "Binary.class";
public class BinaryTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "Binary";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
}
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

21
test/bytecode/BinaryTest2.java
View File

@ -20,15 +20,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class BinaryTest2 {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "Binary2.jav";
public final static String outputFile = "Binary2.class";
public class BinaryTest2 extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "Binary2";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

23
test/bytecode/BoolLitTest.java
View File

@ -20,15 +20,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class BoolLitTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "BoolLit.jav";
public final static String outputFile = "BoolLit.class";
public class BoolLitTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "BoolLit";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
}
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

21
test/bytecode/CharLitTest.java
View File

@ -20,15 +20,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class CharLitTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "CharLitTest.jav";
public final static String outputFile = "CharLitTest.class";
public class CharLitTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "CharLit";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

21
test/bytecode/ConditionTest.java
View File

@ -20,15 +20,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class ConditionTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "Condition.jav";
public final static String outputFile = "Condition.class";
public class ConditionTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "Condition";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

21
test/bytecode/EmptyClassTest.java
View File

@ -20,15 +20,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class EmptyClassTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "EmptyClass.jav";
public final static String outputFile = "EmptyClass.class";
public class EmptyClassTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "EmptyClass";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

21
test/bytecode/FieldDeclarationTest.java
View File

@ -2,13 +2,20 @@ package bytecode;
import org.junit.Test;
public class FieldDeclarationTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "FieldDeclaration.jav";
public final static String outputFile = "FieldDeclaration.class";
public class FieldDeclarationTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "FieldDeclaration";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}
}

6
test/bytecode/ForTest.jav
View File

@ -1,6 +1,6 @@
class IfElse{
method(){
for( i = 0; i < 10 ; i = i++){
class ForTest{
void method(){
for(Integer i = 0; i < 10 ; i = i + 1){
}
}

20
test/bytecode/ForTest.java
View File

@ -3,14 +3,20 @@ package bytecode;
import org.junit.Ignore;
import org.junit.Test;
public class ForTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "ForTest.jav";
public final static String outputFile = "ForTest.class";
public class ForTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "ForTest";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
@Ignore
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

21
test/bytecode/IdTest.java
View File

@ -2,13 +2,20 @@ package bytecode;
import org.junit.Test;
public class IdTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "Id.jav";
public final static String outputFile = "Id.class";
public class IdTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "Id";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}
}

2
test/bytecode/IdentityField.jav
View File

@ -1,3 +1,3 @@
class Id {
class IdentityField {
<GPM, FNF extends GPM> Fun1<? extends GPM, ? super FNF> op = (x) -> x;
}

21
test/bytecode/IdentityFieldTest.java
View File

@ -2,13 +2,20 @@ package bytecode;
import org.junit.Test;
public class IdentityFieldTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "IdentityField.jav";
public final static String outputFile = "IdentityField.class";
public class IdentityFieldTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "IdentityField";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}
}

21
test/bytecode/IdentityTest.java
View File

@ -2,13 +2,20 @@ package bytecode;
import org.junit.Test;
public class IdentityTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "Identity.jav";
public final static String outputFile = "Identity.class";
public class IdentityTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "Identity";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}
}

2
test/bytecode/IfElseIfStatement.jav
View File

@ -4,6 +4,8 @@ class IfElseIfStatement{
return 0;
}else if(flag){
return 1;
}else{
return 2;
}
}

19
test/bytecode/IfElseIfStatementTest.java
View File

@ -2,13 +2,20 @@ package bytecode;
import org.junit.Test;
public class IfElseIfStatementTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "IfElseIfStatement.jav";
public final static String outputFile = "IfElseIfStatement.class";
public class IfElseIfStatementTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "IfElseIfStatement";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory);
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

19
test/bytecode/IfElseStatementTest.java
View File

@ -2,13 +2,20 @@ package bytecode;
import org.junit.Test;
public class IfElseStatementTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "IfElseStatement.jav";
public final static String outputFile = "IfElseStatement.class";
public class IfElseStatementTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "IfElseStatement";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory);
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

19
test/bytecode/IfStatementTest.java
View File

@ -2,13 +2,20 @@ package bytecode;
import org.junit.Test;
public class IfStatementTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "IfStatement.jav";
public final static String outputFile = "IfStatement.class";
public class IfStatementTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "IfStatement";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory);
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

22
test/bytecode/LambdaExpr2.java → test/bytecode/LambdaExpr2Test.java
View File

@ -21,16 +21,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class LambdaExpr2 {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "LambdaExpr2.jav";
public final static String outputFile = "LambdaExpr2.class";
public class LambdaExpr2Test extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "LambdaExpr";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
@Ignore
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

23
test/bytecode/LambdaExpr.java → test/bytecode/LambdaExprTest.java
View File

@ -20,15 +20,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class LambdaExpr {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "LambdaExpr.jav";
public final static String outputFile = "LambdaExpr.class";
public class LambdaExprTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "LambdaExpr";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
}
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

21
test/bytecode/MainTest.java
View File

@ -20,15 +20,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class MainTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "Main.jav";
public final static String outputFile = "Main.class";
public class MainTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "Main";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

2
test/bytecode/Matrix_lambda.jav
View File

@ -1,5 +1,5 @@
import java.util.Vector;
class Matrix extends Vector<Vector<Integer>> {
class Matrix_lambda extends Vector<Vector<Integer>> {
op = (Matrix m) -> (f) -> f.apply(this, m);
}

2
test/bytecode/Matrix_lambda2.jav
View File

@ -1,4 +1,4 @@
class Matrix2 {
class Matrix_lambda2 {
op = (f) -> f.apply(2);
}

2
test/bytecode/Matrix_lambda3.jav
View File

@ -1,4 +1,4 @@
class Matrix3 {
class Matrix_lambda3 {
op = (f) -> f.apply();
}

21
test/bytecode/Matrix_lambdaTest.java
View File

@ -2,13 +2,20 @@ package bytecode;
import org.junit.Test;
public class Matrix_lambdaTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "Matrix_lambda.jav";
public final static String outputFile = "Matrix_lambda.class";
public class Matrix_lambdaTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "Matrix_lambda";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}
}

21
test/bytecode/Matrix_lambdaTest2.java
View File

@ -2,13 +2,20 @@ package bytecode;
import org.junit.Test;
public class Matrix_lambdaTest2 {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "Matrix_lambda2.jav";
public final static String outputFile = "Matrix2.class";
public class Matrix_lambdaTest2 extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "Matrix_lambda2";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}
}

21
test/bytecode/Matrix_lambdaTest3.java
View File

@ -2,13 +2,20 @@ package bytecode;
import org.junit.Test;
public class Matrix_lambdaTest3 {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "Matrix_lambda3.jav";
public final static String outputFile = "Matrix3.class";
public class Matrix_lambdaTest3 extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "Matrix_lambda3";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}
}

18
test/bytecode/MethodAndVariable.jav Normal file
View File

@ -0,0 +1,18 @@
class MethodAndVariable{
public Integer method(Integer parameter){
Integer lokaleVariable;
lokaleVariable = 2;
Integer lokaleVariable2;
lokaleVariable2 = method2(lokaleVariable);
return parameter+lokaleVariable2;
}
public Integer method2(Integer parameter){
Integer lokaleVariable;
lokaleVariable = 2;
return parameter+lokaleVariable;
}
}

21
test/bytecode/MethodCallTest.java
View File

@ -20,15 +20,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class MethodCallTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "MethodCall.jav";
public final static String outputFile = "MethodCall.class";
public class MethodCallTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "MethodCall";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

23
test/bytecode/MethodEmpty.java
View File

@ -20,15 +20,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class MethodEmpty {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "MethodEmpty.jav";
public final static String outputFile = "MethodEmpty.class";
public class MethodEmpty extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "MethodEmpty";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
}
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

23
test/bytecode/MethodEmptyRetType.java
View File

@ -20,15 +20,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class MethodEmptyRetType {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "MethodEmptyRetType.jav";
public final static String outputFile = "MethodEmptyRetType.class";
public class MethodEmptyRetType extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "MethodEmptyRetType";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
}
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

26
test/bytecode/MethodsAndVariableTest.java Normal file
View File

@ -0,0 +1,26 @@
package bytecode;
import static org.junit.Assert.*;
import org.junit.Test;
import bytecode.SourceFileBytecodeTest;
public class MethodsAndVariableTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "MethodAndVariable";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

5
test/bytecode/MultiClass.jav Normal file
View File

@ -0,0 +1,5 @@
class MultiClass{
}
class MultiClass2{
}

49
test/bytecode/MultiClassTest.java Normal file
View File

@ -0,0 +1,49 @@
package bytecode;
import static org.junit.Assert.*;
import java.io.File;
import java.io.IOException;
import junit.framework.TestCase;
import org.junit.Test;
import plugindevelopment.TypeInsertTester;
import de.dhbwstuttgart.core.MyCompiler;
import de.dhbwstuttgart.core.MyCompilerAPI;
import de.dhbwstuttgart.logger.LoggerConfiguration;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.parser.JavaParser.yyException;
import de.dhbwstuttgart.typeinference.ByteCodeResult;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class MultiClassTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "MultiClass";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
@Test
public void testConstruct2() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName+2);
Object obj = cls.newInstance();
assertTrue(true);
}
}

39
test/bytecode/NewStatementTest.java
View File

@ -23,35 +23,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class NewStatementTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "NewStatement.jav";
public final static String outputFile = "NewStatement.class";
public class NewStatementTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "NewStatement";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory);
}
/*
@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};
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
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);
}
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
*/
}

23
test/bytecode/ParameterTest.java
View File

@ -20,15 +20,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class ParameterTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "Parameter.jav";
public final static String outputFile = "Parameter.class";
public class ParameterTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "Parameter";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
}
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

24
test/bytecode/PostDecrement.java
View File

@ -21,16 +21,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class PostDecrement {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "PostDecrement.jav";
public final static String outputFile = "PostDecrement.class";
public class PostDecrement extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "PostDecrement";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
@Ignore
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
}
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

24
test/bytecode/PostIncrement.java
View File

@ -21,16 +21,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class PostIncrement {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "PostIncrement.jav";
public final static String outputFile = "PostIncrement.class";
public class PostIncrement extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "PostIncrement";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
@Ignore
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
}
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

23
test/bytecode/ReturnTest.java
View File

@ -20,15 +20,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class ReturnTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "Return.jav";
public final static String outputFile = "Return.class";
public class ReturnTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "Return";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
}
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

21
test/bytecode/RunnableTest.java
View File

@ -2,13 +2,20 @@ package bytecode;
import org.junit.Test;
public class RunnableTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "Runnable.jav";
public final static String outputFile = "Runnable.class";
public class RunnableTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "Runnable";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}
}

24
test/bytecode/SingleClassTester.java
View File

@ -38,20 +38,20 @@ public class SingleClassTester {
Menge<ByteCodeResult> bytecode = compiler.generateBytecode(sourceFiles, results);
//System.out.println(bytecode);
ByteCodeResult result = bytecode.firstElement();
JavaClass javaClass = result.getByteCode().getJavaClass();
javaClass.dump(new File(outputDirectory+javaClass.getClassName()+".class"));
for(ClassGenerator cg: result.getByteCode().getExtraClasses().values()){
JavaClass jc = cg.getJavaClass();
jc.dump(new File(outputDirectory+jc.getClassName()+".class"));
for(ByteCodeResult result: bytecode){
JavaClass javaClass = result.getByteCode().getJavaClass();
javaClass.dump(new File(outputDirectory+javaClass.getClassName()+".class"));
for(ClassGenerator cg: result.getByteCode().getExtraClasses().values()){
JavaClass jc = cg.getJavaClass();
jc.dump(new File(outputDirectory+jc.getClassName()+".class"));
}
Logger.getLogger("SingleClassTester").error(result.getByteCode().getJavaClass().toString(), Section.CODEGEN);
}
Logger.getLogger("SingleClassTester").error(result.getByteCode().getJavaClass().toString(), Section.CODEGEN);
} catch (IOException | yyException e) {

23
test/bytecode/StringLitTest.java
View File

@ -20,15 +20,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class StringLitTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "StringLitTest.jav";
public final static String outputFile = "StringLitTest.class";
public class StringLitTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "StringLitTest";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
}
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

23
test/bytecode/SystemOutPrintlnTest.java
View File

@ -20,15 +20,20 @@ import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class SystemOutPrintlnTest {
public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
public final static String testFile = "SystemOutPrintln.jav";
public final static String outputFile = "SystemOutPrintln.class";
public class SystemOutPrintlnTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "SystemOutPrintln";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void test() {
SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory);
}
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
}
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

2
test/bytecode/Test3.java
View File

@ -1,6 +1,6 @@
class Test3{
public static void main(String[] args){
System.out.println(new LambdaExpr2().op.apply());
System.out.println(new LambdaExpr2Test().op.apply());
}
}

8
test/bytecode/Variable.jav Normal file
View File

@ -0,0 +1,8 @@
class Variable{
public Integer method(Integer parameter){
Integer lokaleVariable;
lokaleVariable = 2;
return parameter+lokaleVariable;
}
}

35
test/bytecode/VariableTest.java Normal file
View File

@ -0,0 +1,35 @@
package bytecode;
import static org.junit.Assert.*;
import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Vector;
import org.junit.Test;
import org.junit.Ignore;
import bytecode.SourceFileBytecodeTest;
public class VariableTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "Variable";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

Some files were not shown because too many files have changed in this diff Show More