i21017/JavaCompilerCore
1
0
Fork 0
forked from JavaTX/JavaCompilerCore
Code Pull Requests Activity

Merge mit bytecode

Browse Source
This commit is contained in:
JanUlrich 2015-12-08 13:34:16 +01:00
commit 5f428894ea
62 changed files with 377 additions and 232 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -62,22 +62,13 @@ public class ClassGenerator extends ClassGen{
//return getNearestType((TypePlaceholder) t);
return new TypePlaceholderType((TypePlaceholder) t);
}else{
return t.getBytecodeType(this);
return t.getBytecodeType(this, getTypeinferenceResults().getTypeReconstructions().firstElement());
}
}
public org.apache.commons.bcel6.generic.Type getNearestUsedType(TypePlaceholder toTPH){
return this.getNearestUsedType(toTPH, null);
}
public Type resolveTPH(TypePlaceholder typePlaceholder) {
return resolveTPH(typePlaceholder, null);
}
public Type resolveTPH(TypePlaceholder typePlaceholder, Menge<TypePlaceholder> toOneOfTheseTypes) {
return tiResult.getTypeOfPlaceholder(typePlaceholder, toOneOfTheseTypes);
}
public String createLambdaMethodName() {
return "lambda$methode$"+(lambdaMethodeNr++);
}
@ -135,7 +126,7 @@ public class ClassGenerator extends ClassGen{
//Signatur setzen:
String typeParameters = this.generateParameterSignature();
String superClassSignature = this.superClass.getBytecodeSignature(this);
String superClassSignature = this.superClass.getBytecodeSignature(this, null);
String classSignature = typeParameters + superClassSignature;
if(classSignature.length()>0){
this.addAttribute(new Signature(cp.addUtf8("Signature"),2,cp.addUtf8(classSignature),cp.getConstantPool()));
@ -153,7 +144,7 @@ public class ClassGenerator extends ClassGen{
TypePlaceholder tph = it.next();
//ret += tph.getBytecodeMethodSignature(this);
//ret += ":";
ret += tph.getClassSignature(this);
ret += tph.getClassSignature(this, getTypeinferenceResults().getTypeReconstructions().firstElement());
}
ret += ">";
}

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

@ -26,6 +26,7 @@ import de.dhbwstuttgart.syntaxtree.ParameterList;
import de.dhbwstuttgart.syntaxtree.statement.Block;
import de.dhbwstuttgart.syntaxtree.statement.Return;
import de.dhbwstuttgart.syntaxtree.type.FunN;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
public class DHBWInstructionFactory extends InstructionFactory{
@ -46,7 +47,7 @@ public class DHBWInstructionFactory extends InstructionFactory{
* @param lambdaMethod
* @return
*/
public INVOKEDYNAMIC createInvokeDynamic( String interfaceMethodName, String invokeDynamicMethodType, FunN interfaceMethodType, MethodGen lambdaMethod ) {
public INVOKEDYNAMIC createInvokeDynamic( String interfaceMethodName, String invokeDynamicMethodType, FunN interfaceMethodType, MethodGen lambdaMethod, TypeinferenceResultSet rs) {
//Zuerst die Bootstrap-Methode erstellen: Diese müssen dann in ein BootstrapMethods-Attribut zusammengefasst und dem Classfile hinzugefügt werden
//this.cp.addMethodref(lambdaMethod);
@ -67,7 +68,7 @@ public class DHBWInstructionFactory extends InstructionFactory{
String lambdaTypeParameterList = "()";
ConstantMethodType lambdaMethodType1 = new ConstantMethodType(this.cp.addUtf8(interfaceMethodType.getBytecodeInvokeDynamicSignatureUpperBound(cg))); //TODO: Hier den Grund finden, warum Object stehen muss.
ConstantMethodType lambdaMethodType = new ConstantMethodType(this.cp.addUtf8(interfaceMethodType.getBytecodeInvokeDynamicSignature(cg)));
ConstantMethodType lambdaMethodType = new ConstantMethodType(this.cp.addUtf8(interfaceMethodType.getBytecodeInvokeDynamicSignature(cg, rs)));
int implMethodKind = 7; // 7 = InvokeSpecial @see https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-5.html#jvms-5.4.3.5
ConstantMethodHandle implMethod = new ConstantMethodHandle(implMethodKind,cg.getConstantPool().addMethodref(lambdaMethod)); //Das zweite Argument ist der MethodRef zur LambdaMethode

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

@ -14,6 +14,7 @@ import de.dhbwstuttgart.syntaxtree.ParameterList;
import de.dhbwstuttgart.syntaxtree.statement.Block;
import de.dhbwstuttgart.syntaxtree.statement.Return;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
public class MethodGenerator extends MethodGen{
@ -22,11 +23,11 @@ public class MethodGenerator extends MethodGen{
super(access_flags, return_type, arg_types, arg_names, method_name, class_name, il, cp);
}
public Method createMethod(ClassGenerator cg, ParameterList parameter, de.dhbwstuttgart.syntaxtree.type.Type retType, Block block){
public Method createMethod(ClassGenerator cg, ParameterList parameter, de.dhbwstuttgart.syntaxtree.type.Type retType, Block block, TypeinferenceResultSet rs){
MethodGen method = this;
DHBWInstructionFactory factory = cg.getInstructionFactory();
InstructionList blockInstructions = block.genByteCode(cg);
InstructionList blockInstructions = block.genByteCode(cg, rs);
InstructionList il = this.getInstructionList();
il.append(blockInstructions);//Die vom Block generierten Instructions an die InstructionList der Methode anfügen
@ -42,12 +43,12 @@ public class MethodGenerator extends MethodGen{
//Die korrekte Signatur für die Methode anhängen. Hier sind dann auch die Parameter von RefTypes enthalten:
String paramTypesSig = "(";
for(FormalParameter p : parameter){
paramTypesSig += p.getType().getBytecodeSignature(cg);
paramTypesSig += p.getType().getBytecodeSignature(cg, rs);
Logger.getLogger("MethodGenerator").error(paramTypesSig, Section.CODEGEN);
}
paramTypesSig += ")";
String retTypeSig = retType.getBytecodeSignature(cg);
String retTypeSig = retType.getBytecodeSignature(cg, rs);
method.addAttribute(factory.createSignatureAttribute(paramTypesSig+retTypeSig));

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

@ -110,7 +110,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
}
InstructionList fieldInitializations = new InstructionList();
for(FieldDeclaration f : fieldDeclarations){
fieldInitializations.append(f.genByteCode(_cg));
fieldInitializations.append(f.genByteCode(_cg, typeinferenceResults.getTypeReconstructions().firstElement()));
}
//Die Konstruktoren müssen die Feld initialisierungswerte beinhalten:
for(Constructor c : constructors){

7
src/de/dhbwstuttgart/syntaxtree/Constructor.java
View File

@ -29,6 +29,7 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.SingleConstraint;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.ConstructorAssumption;
import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
import de.dhbwstuttgart.typeinference.assumptions.ParameterAssumption;
@ -66,7 +67,7 @@ public class Constructor extends Method {
InstructionList il = new InstructionList(); //sollte nicht new sein sondern aus Block kommen
Class parentClass = this.getParentClass();
MethodGenerator method = new MethodGenerator(Constants.ACC_PUBLIC, this.getType().getBytecodeType(cg), this.parameterlist.getBytecodeTypeList(cg) , this.parameterlist.getParameterNameArray(), "<init>", parentClass.name, il, _cp);
MethodGenerator method = new MethodGenerator(Constants.ACC_PUBLIC, this.getType().getBytecodeType(cg, null), this.parameterlist.getBytecodeTypeList(cg,null) , this.parameterlist.getParameterNameArray(), "<init>", parentClass.name, il, _cp);
//FieldInitializations an Block anfügen
Block block = this.get_Block();
@ -78,7 +79,7 @@ public class Constructor extends Method {
//method.setMaxStack(); //Die Stack Größe automatisch berechnen lassen (erst nach dem alle Instructions angehängt wurden)
cg.addMethod(method.createMethod(cg, getParameterList(), this.getType(), get_Block()));
cg.addMethod(method.createMethod(cg, getParameterList(), this.getType(), get_Block(), null));
}
/**
@ -91,7 +92,7 @@ public class Constructor extends Method {
il = toInsert;
}
@Override
public InstructionList genByteCode(ClassGenerator cg){
public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs){
return il;
}
}

13
src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java
View File

@ -22,6 +22,7 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.OderConstraint;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.SingleConstraint;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
@ -170,19 +171,19 @@ public class FieldDeclaration extends Field{
* @param cg
* @return - Die InstructionList, welche das Feld initialisiert
*/
public InstructionList genByteCode(ClassGenerator cg) {
public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
//Das Feld an die Klasse anfügen:
FieldGen field = new FieldGen(0, this.getType().getBytecodeType(cg), this.getDescription(), cg.getConstantPool());
field.addAttribute(cg.getInstructionFactory().createSignatureAttribute(this.getType().getBytecodeSignature(cg)));
FieldGen field = new FieldGen(0, this.getType().getBytecodeType(cg, rs), this.getDescription(), cg.getConstantPool());
field.addAttribute(cg.getInstructionFactory().createSignatureAttribute(this.getType().getBytecodeSignature(cg, rs)));
cg.addField(field.getField());
//Die Felddekleration an den Konstruktor anhängen:
InstructionList il = new InstructionList();
il.append(new This(this).genByteCode(cg));
il.append(this.wert.genByteCode(cg));
il.append(new This(this).genByteCode(cg, rs));
il.append(this.wert.genByteCode(cg, rs));
FieldInstruction putFieldInstruction =
cg.getInstructionFactory().createFieldAccess(this.getParentClass().getName().toString(),
this.getDescription(), this.getType().getBytecodeType(cg), Constants.PUTFIELD);
this.getDescription(), this.getType().getBytecodeType(cg, rs), Constants.PUTFIELD);
il.append(putFieldInstruction );
return il;
}

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

@ -236,7 +236,7 @@ public class FormalParameter extends SyntaxTreeNode implements Typeable, TypeIns
public String getDescription() {
String ret = "";
if(this.getType() != null && !(this.getType() instanceof TypePlaceholder)){
ret += this.getType().getBytecodeSignature(null);
ret += this.getType().getBytecodeSignature(null, null);
}
return ret+this.getIdentifier();
}

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

@ -6,6 +6,7 @@ package de.dhbwstuttgart.syntaxtree;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import org.apache.commons.bcel6.Constants;
@ -18,7 +19,9 @@ import org.apache.commons.bcel6.generic.InstructionList;
import org.apache.commons.bcel6.generic.MethodGen;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.Menge.Equal;
import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.bytecode.DHBWConstantPoolGen;
import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
@ -44,6 +47,7 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.SingleConstraint;
import de.dhbwstuttgart.typeinference.TypeInsertable;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
import de.dhbwstuttgart.typeinference.assumptions.ParameterAssumption;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
@ -108,6 +112,8 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
// 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) {
@ -746,11 +752,9 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
}
public void genByteCode(ClassGenerator cg) {
List<Integer> typeReconstructionSetIndexList = cg.getTypeinferenceResults().getTypeReconstructionSetIndexList(this, cg);
for(Integer t: typeReconstructionSetIndexList){
cg.getTypeinferenceResults().setTypeReconstructionSetIndex(t);
List<TypeinferenceResultSet> typeInterferenceResults = cg.getTypeinferenceResults().getTypeReconstructions(this, cg);
for(TypeinferenceResultSet t: typeInterferenceResults){
DHBWConstantPoolGen _cp = cg.getConstantPool();
InstructionList il = new InstructionList();
Class parentClass = this.getParentClass();
@ -763,11 +767,28 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
argumentNames = new String[this.parameterlist.size()];
int i = 0;
for(FormalParameter parameter : this.parameterlist){
argumentTypes[i] = parameter.getType().getBytecodeType(cg);
argumentTypes[i] = parameter.getType().getBytecodeType(cg, t);
argumentNames[i] = parameter.getIdentifier();
i++;
}
if(!createdMethods.contains(argumentTypes, new ArgumentTypeEquals())){
createdMethods.add(argumentTypes);
}
}
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();
//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));
/*
short constants = Constants.ACC_PUBLIC; //Per Definition ist jede Methode public
if(this.modifiers != null && this.modifiers.includesModifier(new Static())) constants += Constants.ACC_STATIC;
@ -778,11 +799,33 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
//Methode generieren und anfügen:
cg.addMethod(method.createMethod(cg, getParameterList(), returnType, get_Block()));
*/
}
}
}
class ArgumentTypeEquals implements Equal<org.apache.commons.bcel6.generic.Type[]>{
@Override
public boolean equal(org.apache.commons.bcel6.generic.Type[] a, org.apache.commons.bcel6.generic.Type[] b) {
if(a.length != b.length){
Logger.getLogger("ArgumentTypeEquals").error("false(length)", Section.CODEGEN);
return false;
}
for(int i = 0; i < a.length; i++){
if(!a[i].equals(b[i])){
String as = a[i].toString();
String bs = b[i].toString();
Logger.getLogger("ArgumentTypeEquals").error("false "+as+" != "+bs, Section.CODEGEN);
return false;
}
}
Logger.getLogger("ArgumentTypeEquals").error("true", Section.CODEGEN);
return true;
}
}
// ino.end

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

@ -11,6 +11,7 @@ import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
// ino.end
@ -145,11 +146,11 @@ public class ParameterList extends SyntaxTreeNode implements Iterable<FormalPara
return this.formalparameter.size();
}
public org.apache.commons.bcel6.generic.Type[] getBytecodeTypeList(ClassGenerator cg){
public org.apache.commons.bcel6.generic.Type[] getBytecodeTypeList(ClassGenerator cg, TypeinferenceResultSet rs){
org.apache.commons.bcel6.generic.Type[] ret = new org.apache.commons.bcel6.generic.Type[formalparameter.size()];
int i = 0;
for(FormalParameter f : formalparameter){
ret[i] = f.getType().getBytecodeType(cg);
ret[i] = f.getType().getBytecodeType(cg, rs);
i++;
}
return ret;

9
src/de/dhbwstuttgart/syntaxtree/statement/ArgumentList.java
View File

@ -11,6 +11,7 @@ import de.dhbwstuttgart.syntaxtree.FormalParameter;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
public class ArgumentList extends SyntaxTreeNode
{
@ -81,19 +82,19 @@ public class ArgumentList extends SyntaxTreeNode
return expr;
}
public InstructionList generateBytecode(ClassGenerator cg){
public InstructionList generateBytecode(ClassGenerator cg, TypeinferenceResultSet rs){
InstructionList ret = new InstructionList();
for(Expr e : expr){
ret.append(e.genByteCode(cg));
ret.append(e.genByteCode(cg, rs));
}
return ret;
}
public org.apache.commons.bcel6.generic.Type[] getBytecodeTypeList(ClassGenerator cg){
public org.apache.commons.bcel6.generic.Type[] getBytecodeTypeList(ClassGenerator cg, TypeinferenceResultSet rs){
org.apache.commons.bcel6.generic.Type[] ret = new org.apache.commons.bcel6.generic.Type[expr.size()];
int i = 0;
for(Expr e : expr){
ret[i] = e.getType().getBytecodeType(cg);
ret[i] = e.getType().getBytecodeType(cg, rs);
i++;
}
return ret;

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

@ -34,6 +34,7 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.SingleConstraint;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.Unify;
@ -179,10 +180,10 @@ public class Assign extends Expr
public static int counterAssign = 0; //Zaehlvariable f<EFBFBD>r ISTORE
@Override
public InstructionList genByteCode(ClassGenerator cg) {
public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
// TODO Auto-generated method stub
InstructionFactory _factory = new InstructionFactory(cg, cg.getConstantPool());
InstructionList il = expr2.genByteCode(cg);//expr2 rechte expr
InstructionList il = expr2.genByteCode(cg, rs);//expr2 rechte expr

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

@ -39,6 +39,7 @@ import de.dhbwstuttgart.typeinference.OderConstraint;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.SingleConstraint;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.UndConstraint;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
@ -227,9 +228,9 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
InstructionList linkeSeite = this.expr1.genByteCode(_cg);
InstructionList rechteSeite = this.expr2.genByteCode(_cg);
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);
}

5
src/de/dhbwstuttgart/syntaxtree/statement/Block.java
View File

@ -33,6 +33,7 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.SingleConstraint;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
@ -256,12 +257,12 @@ public class Block extends Statement
}
@Override
public InstructionList genByteCode(ClassGenerator cg) {
public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
//ConstantPoolGen _cp = cg.getConstantPool();
InstructionList il = new InstructionList();
for(Statement stmt : this.get_Statement()){
il.append(stmt.genByteCode(cg));
il.append(stmt.genByteCode(cg, rs));
}
//il.dispose();

3
src/de/dhbwstuttgart/syntaxtree/statement/BoolLiteral.java
View File

@ -22,6 +22,7 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
@ -130,7 +131,7 @@ public class BoolLiteral extends Literal
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
InstructionFactory _factory = new InstructionFactory(_cg, _cg.getConstantPool());
InstructionList il = new InstructionList();

3
src/de/dhbwstuttgart/syntaxtree/statement/CastExpr.java
View File

@ -23,6 +23,7 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
@ -123,7 +124,7 @@ public class CastExpr extends UnaryExpr
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
// TODO Bytecode
throw new NotImplementedException();
}

3
src/de/dhbwstuttgart/syntaxtree/statement/CharLiteral.java
View File

@ -22,6 +22,7 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
@ -125,7 +126,7 @@ public class CharLiteral extends Literal
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
InstructionFactory _factory = new InstructionFactory(_cg, _cg.getConstantPool());
InstructionList il = new InstructionList();
il.append(new BIPUSH((byte) get_Char()));

3
src/de/dhbwstuttgart/syntaxtree/statement/DoubleLiteral.java
View File

@ -25,6 +25,7 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
@ -145,7 +146,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
}*/
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
ConstantPoolGen cp = _cg.getConstantPool();
//InstructionFactory _factory = new InstructionFactory(cg, cp);
InstructionList il = new InstructionList();

3
src/de/dhbwstuttgart/syntaxtree/statement/EmptyStmt.java
View File

@ -19,6 +19,7 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
@ -89,7 +90,7 @@ public class EmptyStmt extends Statement
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
// TODO Bytecode
throw new NotImplementedException();
}

3
src/de/dhbwstuttgart/syntaxtree/statement/FloatLiteral.java
View File

@ -23,6 +23,7 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
@ -133,7 +134,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
ConstantPoolGen cp = _cg.getConstantPool();
InstructionList il = new InstructionList();

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

@ -34,6 +34,7 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.SingleConstraint;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
import de.dhbwstuttgart.typeinference.unify.Unify;
@ -133,7 +134,7 @@ public class ForStmt extends Statement
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
/*
0: iconst_0
1: istore_1
@ -147,16 +148,16 @@ public class ForStmt extends Statement
InstructionList il = new InstructionList();
il.append(head_Initializer.genByteCode(_cg));
il.append(head_Initializer.genByteCode(_cg, rs));
InstructionHandle ih = il.append(head_Condition.genByteCode(_cg));
InstructionHandle ih = il.append(head_Condition.genByteCode(_cg, rs));
BranchInstruction branch = new IF_ICMPGE(null);
il.append(branch);
il.append(body_Loop_block.genByteCode(_cg));
il.append(body_Loop_block.genByteCode(_cg, rs));
il.append(head_Loop_expr.genByteCode(_cg));
il.append(head_Loop_expr.genByteCode(_cg, rs));
il.append(new GOTO(ih));

9
src/de/dhbwstuttgart/syntaxtree/statement/IfStmt.java
View File

@ -45,6 +45,7 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.SingleConstraint;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
import de.dhbwstuttgart.typeinference.unify.MUB;
@ -178,21 +179,21 @@ public class IfStmt extends Statement
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
InstructionFactory _factory = _cg.getInstructionFactory();
InstructionList il = new InstructionList();
IfInstruction ifInstruction = new IFEQ(null);
il.append(expr.genByteCode(_cg));
il.append(expr.genByteCode(_cg, rs));
//Anmerkung: expr ist vom Typ java.lang.Boolean (per Definition)
il.append(_factory.createInvoke("java.lang.Boolean", "booleanValue", org.apache.commons.bcel6.generic.Type.BOOLEAN, org.apache.commons.bcel6.generic.Type.NO_ARGS, Constants.INVOKEVIRTUAL));
il.append(ifInstruction);
il.append(then_block.genByteCode(_cg));
il.append(then_block.genByteCode(_cg, rs));
if(else_block != null && !(else_block instanceof EmptyStmt)){
GotoInstruction gotoInstruction = new GOTO(null);
il.append(gotoInstruction);
ifInstruction.setTarget(il.append(else_block.genByteCode(_cg)));
ifInstruction.setTarget(il.append(else_block.genByteCode(_cg, rs)));
gotoInstruction.setTarget(il.append(new NOP()));
}else{
ifInstruction.setTarget(il.append(new NOP()));

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

@ -220,7 +220,7 @@ public class InstVar extends Expr
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
// TODO Bytecode
throw new NotImplementedException();
}

3
src/de/dhbwstuttgart/syntaxtree/statement/InstanceOf.java
View File

@ -23,6 +23,7 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
@ -119,7 +120,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
// TODO Bytecode
throw new NotImplementedException();
}

3
src/de/dhbwstuttgart/syntaxtree/statement/IntLiteral.java
View File

@ -26,6 +26,7 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
@ -139,7 +140,7 @@ public class IntLiteral extends Literal
}
@Override
public InstructionList genByteCode(ClassGenerator cg) {
public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
InstructionFactory _factory = new InstructionFactory(cg, cg.getConstantPool());
InstructionList il = new InstructionList();

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

@ -43,6 +43,7 @@ import de.dhbwstuttgart.typeinference.OderConstraint;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.SingleConstraint;
import de.dhbwstuttgart.typeinference.Typeable;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.ParameterAssumption;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
@ -238,12 +239,12 @@ public class LambdaExpression extends Expr{
}
@Override
public InstructionList genByteCode(ClassGenerator cg) {
public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
ConstantPoolGen cp = cg.getConstantPool();
InstructionList il = new InstructionList();
org.apache.commons.bcel6.generic.Type[] paramTypes = params.getBytecodeTypeList(cg);
org.apache.commons.bcel6.generic.Type retType = method_body.getType().getBytecodeType(cg);
org.apache.commons.bcel6.generic.Type[] paramTypes = params.getBytecodeTypeList(cg, rs);
org.apache.commons.bcel6.generic.Type retType = method_body.getType().getBytecodeType(cg, rs);
MethodGenerator lambdaMethod = new MethodGenerator(0, retType,
paramTypes, params.getParameterNameArray(), cg.createLambdaMethodName(),
@ -255,18 +256,18 @@ public class LambdaExpression extends Expr{
String interfaceMethodName = "apply"; //Das ist ein Hack, funktioniert momentan, da nur FunN Interfaces für LambdaAusdrücke funktionieren
il.append(InstructionFactory.createLoad( org.apache.commons.bcel6.generic.Type.OBJECT, 0));
il.append(cg.getInstructionFactory().createInvokeDynamic(interfaceMethodName,this.getLambdaSignature(cg),lambdaType,lambdaMethod));
il.append(cg.getInstructionFactory().createInvokeDynamic(interfaceMethodName,this.getLambdaSignature(cg, rs),lambdaType,lambdaMethod, rs));
cg.addMethod(lambdaMethod.createMethod(cg, params, method_body.getType(), method_body));
cg.addMethod(lambdaMethod.createMethod(cg, params, method_body.getType(), method_body, rs));
return il;
}
private String getLambdaSignature(ClassGenerator cg){
private String getLambdaSignature(ClassGenerator cg, TypeinferenceResultSet rs){
String typeSignature = "(";
typeSignature+=this.getParentClass().getType().getBytecodeType(cg).getSignature();
typeSignature+=this.getParentClass().getType().getBytecodeType(cg, rs).getSignature();
typeSignature += ")";
typeSignature += this.lambdaType.getBytecodeType(cg).getSignature();
typeSignature += this.lambdaType.getBytecodeType(cg, rs).getSignature();
return typeSignature;
}
}

7
src/de/dhbwstuttgart/syntaxtree/statement/LocalOrFieldVar.java
View File

@ -29,6 +29,7 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.SingleConstraint;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
@ -148,14 +149,14 @@ public class LocalOrFieldVar extends Expr
}
@Override
public InstructionList genByteCode(ClassGenerator cg) {
public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
InstructionList il = new InstructionList();
if(this.isFieldAccess){
il.append(cg.getInstructionFactory().createFieldAccess(this.getParentClass().getName().toString(), this.get_Name(), this.getType().getBytecodeType(cg), Constants.GETFIELD));
il.append(cg.getInstructionFactory().createFieldAccess(this.getParentClass().getName().toString(), this.get_Name(), this.getType().getBytecodeType(cg, rs), Constants.GETFIELD));
}
Type type = this.getType();
org.apache.commons.bcel6.generic.Type byteCodeType = type.getBytecodeType(cg);
org.apache.commons.bcel6.generic.Type byteCodeType = type.getBytecodeType(cg, rs);
String name = this.get_Name();

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

@ -29,6 +29,7 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.SingleConstraint;
import de.dhbwstuttgart.typeinference.TypeInsertable;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.LocalVarAssumption;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
@ -429,7 +430,7 @@ public class LocalVarDecl extends Statement implements TypeInsertable
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
// TODO Auto-generated method stub
return new InstructionList();
}

3
src/de/dhbwstuttgart/syntaxtree/statement/LongLiteral.java
View File

@ -22,6 +22,7 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
@ -129,7 +130,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
ConstantPoolGen cp = _cg.getConstantPool();
//InstructionFactory _factory = new InstructionFactory(cg, cp);
InstructionList il = new InstructionList();

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

@ -25,6 +25,7 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.OderConstraint;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.UndConstraint;
import de.dhbwstuttgart.typeinference.assumptions.ClassAssumption;
import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
@ -321,15 +322,15 @@ public class MethodCall extends Expr
*/
@Override
public InstructionList genByteCode(ClassGenerator cg) {
public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
InstructionList il = new InstructionList();
InstructionFactory _factory = new InstructionFactory(cg, cg.getConstantPool());
il.append(receiver.get_Expr().genByteCode(cg));
il.append(receiver.get_Expr().genByteCode(cg, rs));
//Herausfinden, ob eine Methode oder ein Interface aufgerufen wird:
Type receiverType = this.receiver.get_Expr().getType();
de.dhbwstuttgart.syntaxtree.Class receiverClass = this.receiver.getReceiverClass(cg);
de.dhbwstuttgart.syntaxtree.Class receiverClass = this.receiver.getReceiverClass(cg, rs);
short kind = 0;
if(receiverClass.isInterface()){
kind = Constants.INVOKEINTERFACE;
@ -342,15 +343,15 @@ public class MethodCall extends Expr
argumentTypen = new org.apache.commons.bcel6.generic.Type[this.getArgumentList().size()];
int i = 0;
for(Expr argument : this.arglist.expr){
argumentTypen[i] = argument.getType().getBytecodeType(cg);
argumentTypen[i] = argument.getType().getBytecodeType(cg, rs);
//Das Argument auf den Stack legen:
il.append(argument.genByteCode(cg));
il.append(argument.genByteCode(cg, rs));
i++;
}
}
org.apache.commons.bcel6.generic.Type returnType = this.getType().getBytecodeType(cg);
il.append(_factory.createInvoke(receiver.getReceiverClass(cg).getName().toString(), this.get_Name(), returnType , argumentTypen, kind));
org.apache.commons.bcel6.generic.Type returnType = this.getType().getBytecodeType(cg, rs);
il.append(_factory.createInvoke(receiver.getReceiverClass(cg, rs).getName().toString(), this.get_Name(), returnType , argumentTypen, kind));
return il;
}

3
src/de/dhbwstuttgart/syntaxtree/statement/NegativeExpr.java
View File

@ -26,6 +26,7 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
import de.dhbwstuttgart.typeinference.unify.Unify;
@ -112,7 +113,7 @@ public class NegativeExpr extends UnaryExpr
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
// TODO Bytecode
throw new NotImplementedException();
}

5
src/de/dhbwstuttgart/syntaxtree/statement/NewArray.java
View File

@ -20,6 +20,7 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
@ -147,11 +148,11 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
InstructionFactory _factory = new InstructionFactory(_cg, _cg.getConstantPool());
InstructionList il = new InstructionList();
il.append(expr.elementAt(0).genByteCode(_cg));
il.append(expr.elementAt(0).genByteCode(_cg, rs));
il.append(_factory.createNewArray( org.apache.commons.bcel6.generic.Type.getType(getTypeName()), (short)1));

9
src/de/dhbwstuttgart/syntaxtree/statement/NewClass.java
View File

@ -35,6 +35,7 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.SingleConstraint;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.UndConstraint;
import de.dhbwstuttgart.typeinference.assumptions.ConstructorAssumption;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
@ -193,17 +194,17 @@ public class NewClass extends Expr
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
InstructionList il = new InstructionList();
//il.append(_cg.getInstructionFactory().createNew(get_Name()));
il.append(_cg.getInstructionFactory().createNew(this.getType().getBytecodeType(_cg).toString()));
il.append(_cg.getInstructionFactory().createNew(this.getType().getBytecodeType(_cg, rs).toString()));
il.append(InstructionConstants.DUP);
if(arglist!=null){
il.append(arglist.generateBytecode(_cg));
il.append(arglist.generateBytecode(_cg, rs));
il.append(_cg.getInstructionFactory().createInvoke(this.getType().getDescription(), "<init>",
org.apache.commons.bcel6.generic.Type.VOID,
this.arglist.getBytecodeTypeList(_cg), Constants.INVOKESPECIAL));
this.arglist.getBytecodeTypeList(_cg, rs), Constants.INVOKESPECIAL));
}else{
il.append(_cg.getInstructionFactory().createInvoke(this.getType().getDescription(), "<init>",
org.apache.commons.bcel6.generic.Type.VOID,

3
src/de/dhbwstuttgart/syntaxtree/statement/NotExpr.java
View File

@ -26,6 +26,7 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.OderConstraint;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
import de.dhbwstuttgart.typeinference.unify.Unify;
@ -136,7 +137,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
// TODO Bytecode
throw new NotImplementedException();
}

3
src/de/dhbwstuttgart/syntaxtree/statement/Null.java
View File

@ -22,6 +22,7 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
@ -95,7 +96,7 @@ public class Null extends Literal
}
@Override
public InstructionList genByteCode(ClassGenerator cg) {
public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
InstructionFactory _factory = new InstructionFactory(cg, cg.getConstantPool());
InstructionList il = new InstructionList();

3
src/de/dhbwstuttgart/syntaxtree/statement/PositivExpr.java
View File

@ -20,6 +20,7 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
@ -120,7 +121,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
// TODO Bytecode
throw new NotImplementedException();
}

3
src/de/dhbwstuttgart/syntaxtree/statement/PostDecExpr.java
View File

@ -26,6 +26,7 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
import de.dhbwstuttgart.typeinference.unify.Unify;
@ -93,7 +94,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
// TODO Bytecode
throw new NotImplementedException();
}

3
src/de/dhbwstuttgart/syntaxtree/statement/PostIncExpr.java
View File

@ -30,6 +30,7 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.OderConstraint;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.UndConstraint;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
@ -103,7 +104,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
public static int counterPostInc = 0;
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
InstructionFactory _factory = new InstructionFactory(_cg, _cg.getConstantPool());
InstructionList il = new InstructionList();
counterPostInc++;

3
src/de/dhbwstuttgart/syntaxtree/statement/PreDecExpr.java
View File

@ -26,6 +26,7 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
import de.dhbwstuttgart.typeinference.unify.Unify;
@ -92,7 +93,7 @@ public class PreDecExpr extends UnaryExpr
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
// TODO Bytecode
throw new NotImplementedException();
}

3
src/de/dhbwstuttgart/syntaxtree/statement/PreIncExpr.java
View File

@ -26,6 +26,7 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
import de.dhbwstuttgart.typeinference.unify.Unify;
@ -94,7 +95,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
// TODO Bytecode
throw new NotImplementedException();
}

5
src/de/dhbwstuttgart/syntaxtree/statement/Receiver.java
View File

@ -18,6 +18,7 @@ import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.ClassAssumption;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
@ -101,10 +102,10 @@ public class Receiver
}
*/
public Class getReceiverClass(ClassGenerator cg){
public Class getReceiverClass(ClassGenerator cg, TypeinferenceResultSet rs){
de.dhbwstuttgart.syntaxtree.type.Type receiverType = this.get_Expr().getType();
if(receiverType instanceof TypePlaceholder){
receiverType = cg.resolveTPH((TypePlaceholder)receiverType);
receiverType = rs.getTypeOfPlaceholder((TypePlaceholder)receiverType);
}
if(!(receiverType instanceof RefType)){
throw new TypeinferenceException("Typ des Receivers nicht eindeutig",this.get_Expr());

7
src/de/dhbwstuttgart/syntaxtree/statement/Return.java
View File

@ -25,6 +25,7 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.SingleConstraint;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
@ -134,12 +135,12 @@ public class Return extends Statement
}
@Override
public InstructionList genByteCode(ClassGenerator cg) {
InstructionList il = retexpr.genByteCode(cg);
public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
InstructionList il = retexpr.genByteCode(cg, rs);
InstructionFactory _factory = new InstructionFactory(cg, cg.getConstantPool());
org.apache.commons.bcel6.generic.Type retType = this.getReturnType().getBytecodeType(cg);//retexpr.getType().getBytecodeType();
org.apache.commons.bcel6.generic.Type retType = this.getReturnType().getBytecodeType(cg, rs);//retexpr.getType().getBytecodeType();
il.append(_factory.createReturn(retType ));
return il;

3
src/de/dhbwstuttgart/syntaxtree/statement/Statement.java
View File

@ -26,6 +26,7 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.Typeable;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
@ -130,7 +131,7 @@ public abstract class Statement extends SyntaxTreeNode implements IItemWithOffse
}
public abstract InstructionList genByteCode(ClassGenerator _cg);
public abstract InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs);
}

3
src/de/dhbwstuttgart/syntaxtree/statement/StringLiteral.java
View File

@ -28,6 +28,7 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
@ -123,7 +124,7 @@ public class StringLiteral extends Literal
}
//public static int counterString = 0;
@Override
public InstructionList genByteCode(ClassGenerator cg) {
public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
ConstantPoolGen cp = cg.getConstantPool();
InstructionFactory _factory = new InstructionFactory(cg, cp);
InstructionList il = new InstructionList();

3
src/de/dhbwstuttgart/syntaxtree/statement/SuperCall.java
View File

@ -28,6 +28,7 @@ import de.dhbwstuttgart.syntaxtree.type.Void;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.ConstructorAssumption;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
@ -92,7 +93,7 @@ public class SuperCall extends ThisCall
}
@Override
public InstructionList genByteCode(ClassGenerator cg) {
public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
InstructionFactory _factory = new InstructionFactory(cg, cg.getConstantPool());
InstructionList il = new InstructionList();
Type superClass = this.getParentClass().getSuperClass();

3
src/de/dhbwstuttgart/syntaxtree/statement/This.java
View File

@ -28,6 +28,7 @@ import de.dhbwstuttgart.syntaxtree.type.Void;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.ConstructorAssumption;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
@ -149,7 +150,7 @@ public class This extends Expr
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
InstructionList il = new InstructionList();
il.append(InstructionFactory.createLoad( org.apache.commons.bcel6.generic.Type.OBJECT, 0));
return il;

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

@ -29,6 +29,7 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.SingleConstraint;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
@ -137,7 +138,7 @@ public class WhileStmt extends Statement
}
@Override
public InstructionList genByteCode(ClassGenerator _cg) {
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
// TODO Bytecode
throw new NotImplementedException();
}

3
src/de/dhbwstuttgart/syntaxtree/type/FreshWildcardType.java
View File

@ -6,6 +6,7 @@ import de.dhbwstuttgart.parser.JavaClassName;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
public class FreshWildcardType extends ObjectType {
@ -172,7 +173,7 @@ public class FreshWildcardType extends ObjectType {
}
@Override
public org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg) {
public org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg, TypeinferenceResultSet rs) {
// TODO: Bytecode
return null;
}

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

@ -3,6 +3,7 @@ package de.dhbwstuttgart.syntaxtree.type;
import java.util.Iterator;
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;
@ -116,13 +117,13 @@ public class FunN extends RefType {
return 0;
}
public String getBytecodeInvokeDynamicSignature(ClassGenerator cg) {
public String getBytecodeInvokeDynamicSignature(ClassGenerator cg, TypeinferenceResultSet rs) {
String ret = "(";
for(Type t : T){
ret+=t.getBytecodeType(cg).getSignature();
ret+=t.getBytecodeType(cg, rs).getSignature();
}
ret +=")";
ret+= R.getBytecodeType(cg).getSignature();
ret+= R.getBytecodeType(cg, rs).getSignature();
return ret;
}

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

@ -17,7 +17,7 @@ public class GenericClassType extends RefType{
}
@Override
public String getBytecodeSignature(ClassGenerator cg) {
public String getBytecodeSignature(ClassGenerator cg, TypeinferenceResultSet rs) {
return "L"+getTypeName()+";";
}
}

3
src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java
View File

@ -13,6 +13,7 @@ import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.SingleConstraint;
import de.dhbwstuttgart.typeinference.TypeInsertable;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
@ -232,7 +233,7 @@ public class GenericTypeVar extends ObjectType
}
@Override
public org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg) {
public org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg, TypeinferenceResultSet rs) {
// TODO Bytecode
return null;
}

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

@ -822,8 +822,9 @@ public class RefType extends ObjectType implements IMatchable
}
}
public org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg) {
org.apache.commons.bcel6.generic.ObjectType ret = new org.apache.commons.bcel6.generic.ObjectType(getCombinedType(cg));
@Override
public org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg, TypeinferenceResultSet rs) {
org.apache.commons.bcel6.generic.ObjectType ret = new org.apache.commons.bcel6.generic.ObjectType(getCombinedType(cg, rs));
if(this.IsArray()){
//Hier wird einfachhalber von einer Dimension ausgegangen. Arrays sind im Bytecode nur für main-Methode relevant
return new org.apache.commons.bcel6.generic.ArrayType(ret, 1);
@ -833,11 +834,11 @@ public class RefType extends ObjectType implements IMatchable
}
@Override
public String getBytecodeSignature(ClassGenerator cg) {
String combinedType = getCombinedType(cg);
public String getBytecodeSignature(ClassGenerator cg, TypeinferenceResultSet rs) {
String combinedType = getCombinedType(cg, rs);
if(!combinedType.equals(getName().toString())){
getSuperWildcardTypes();
Class generatedClass = ASTFactory.createClass(getCombinedType(cg), getGenericClassType(), null, null, new SourceFile());
Class generatedClass = ASTFactory.createClass(getCombinedType(cg, rs), getGenericClassType(), null, null, new SourceFile());
cg.addExtraClass(generatedClass.genByteCode(new TypeinferenceResults()).getByteCode());
}
@ -845,7 +846,7 @@ public class RefType extends ObjectType implements IMatchable
return ret;
}
public String getCombinedType(ClassGenerator cg){
public String getCombinedType(ClassGenerator cg, TypeinferenceResultSet rs){
//Bsp.: Ljava/util/Vector<Ljava/lang/String;>;
StringBuilder sb = new StringBuilder();
@ -854,11 +855,11 @@ public class RefType extends ObjectType implements IMatchable
sb.append("%%");
for(Type type: parameter){
if(type instanceof RefType){
sb.append(((RefType) type).getCombinedType(cg).replace(".", "%"));
sb.append(((RefType) type).getCombinedType(cg, rs).replace(".", "%"));
}else if(type instanceof TypePlaceholder){
sb.append(((TypePlaceholder) type).getBytecodeType(cg).toString().replace(".", "%"));
sb.append(((TypePlaceholder) type).getBytecodeType(cg, rs).toString().replace(".", "%"));
}else{
sb.append(type.getBytecodeType(cg).toString().replace(".", "%"));
sb.append(type.getBytecodeType(cg, rs).toString().replace(".", "%"));
}
sb.append("%");

5
src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java
View File

@ -5,6 +5,7 @@ import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
@ -163,8 +164,8 @@ public class SuperWildcardType extends WildcardType implements ITypeContainer, I
*/
@Override
public String getBytecodeSignature(ClassGenerator cg) {
return "-" + this.innerType.getBytecodeSignature(cg);
public String getBytecodeSignature(ClassGenerator cg, TypeinferenceResultSet rs) {
return "-" + this.innerType.getBytecodeSignature(cg, rs);
}

11
src/de/dhbwstuttgart/syntaxtree/type/Type.java
View File

@ -12,6 +12,7 @@ import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.syntaxtree.misc.UsedId;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
@ -309,7 +310,7 @@ public abstract class Type extends SyntaxTreeNode implements IItemWithOffset
return this;
}
public abstract org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg);
public abstract org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg, TypeinferenceResultSet rs);
/**
* Erzeugt einen String, welcher den Typ genauer angibt.
@ -317,16 +318,16 @@ public abstract class Type extends SyntaxTreeNode implements IItemWithOffset
* @param cg
* @return
*/
public String getBytecodeSignature(ClassGenerator cg) {
return this.getBytecodeType(cg).getSignature();
public String getBytecodeSignature(ClassGenerator cg, TypeinferenceResultSet rs) {
return this.getBytecodeType(cg, rs).getSignature();
}
/**
* @param cg
* @return Die Signatur wie sie in Klassensignaturen verwendet wird
*/
public String getClassSignature(ClassGenerator cg){
return this.getBytecodeSignature(cg);
public String getClassSignature(ClassGenerator cg, TypeinferenceResultSet rs){
return this.getBytecodeSignature(cg, rs);
}
}
// ino.end

15
src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java
View File

@ -17,6 +17,7 @@ import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeInsertable;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
@ -436,26 +437,26 @@ public class TypePlaceholder extends ObjectType
}
@Override
public org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg) {
Type resolvedType = cg.resolveTPH(this);
public org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg, TypeinferenceResultSet rs) {
Type resolvedType = rs.getTypeOfPlaceholder(this);
if(resolvedType instanceof TypePlaceholder){
return DHBWInstructionFactory.createObjectType();
}
return resolvedType.getBytecodeType(cg);
return resolvedType.getBytecodeType(cg, rs);
}
@Override
public String getBytecodeSignature(ClassGenerator cg) {
Type resolvedType = cg.resolveTPH(this);
public String getBytecodeSignature(ClassGenerator cg, TypeinferenceResultSet rs) {
Type resolvedType = rs.getTypeOfPlaceholder(this);
if(resolvedType instanceof TypePlaceholder){
cg.addUsedTPH((TypePlaceholder)resolvedType);
return new TypePlaceholderType((TypePlaceholder)resolvedType).getSignature();
}
return resolvedType.getBytecodeSignature(cg);
return resolvedType.getBytecodeSignature(cg, rs);
}
@Override
public String getClassSignature(ClassGenerator cg) {
public String getClassSignature(ClassGenerator cg, TypeinferenceResultSet rs) {
//Die Signaturen in der Klasse bauen sich für Generische Variabeln (also TPHs) folgendermaßen auf: "GVAR:SuperClass"
String ret = this.get_Name();//this.getBytecodeSignature(cg);
//ret = ret.substring(1, ret.length()-1) + ":"; //";" mit ":" ersetzen

12
src/de/dhbwstuttgart/syntaxtree/type/Void.java
View File

@ -5,6 +5,7 @@ import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.core.IItemWithOffset;
import de.dhbwstuttgart.syntaxtree.Method;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
@ -81,16 +82,17 @@ public class Void extends RefType
}
@Override
public org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg) {
public org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg, TypeinferenceResultSet rs) {
return org.apache.commons.bcel6.generic.Type.VOID;
}
public String getBytecodeSignature(ClassGenerator cg) {
return this.getBytecodeType(cg).getSignature();
@Override
public String getBytecodeSignature(ClassGenerator cg, TypeinferenceResultSet rs) {
return this.getBytecodeType(cg, rs).getSignature();
}
public String getBytecodeMethodSignature(ClassGenerator cg) {
return this.getBytecodeSignature(cg);
public String getBytecodeMethodSignature(ClassGenerator cg, TypeinferenceResultSet rs) {
return this.getBytecodeSignature(cg, rs);
}
}
// ino.end

9
src/de/dhbwstuttgart/syntaxtree/type/WildcardType.java
View File

@ -5,6 +5,7 @@ import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
@ -101,13 +102,13 @@ public class WildcardType extends Type{
}
@Override
public org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg) {
return this.innerType.getBytecodeType(cg);
public org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg, TypeinferenceResultSet rs) {
return this.innerType.getBytecodeType(cg, rs);
}
@Override
public String getBytecodeSignature(ClassGenerator cg) {
return this.innerType.getBytecodeSignature(cg);
public String getBytecodeSignature(ClassGenerator cg, TypeinferenceResultSet rs) {
return this.innerType.getBytecodeSignature(cg, rs);
}

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

@ -1,104 +1,58 @@
package de.dhbwstuttgart.typeinference;
import java.util.LinkedList;
import java.util.List;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.syntaxtree.FormalParameter;
import de.dhbwstuttgart.syntaxtree.Method;
import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.typeinference.Menge.Equal;
public class TypeinferenceResults {
private Menge<TypeinferenceResultSet> typeReconstructions;
private Integer typeReconstructionSetIndex = 0;
public TypeinferenceResults() {
typeReconstructions = new Menge<>();
}
public TypeinferenceResults(Menge<TypeinferenceResultSet> typeReconstructions) {
//TODO: filter
int limit = typeReconstructions.size();
Logger.getLogger("TypeinferenceResults").error(new Integer(limit).toString(), Section.CODEGEN);
for(int i = 0; i < limit; i++){
Logger.getLogger("TypeinferenceResults").error(new Integer(i).toString(), Section.CODEGEN);
for(Pair p: typeReconstructions.get(i).getUnifiedConstraints()){
boolean flag = false;
Logger.getLogger("TypeinferenceResults").error(p.toString(), Section.CODEGEN);
if( p.TA1 instanceof SuperWildcardType ||
p.TA1 instanceof ExtendsWildcardType ||
p.TA2 instanceof SuperWildcardType ||
p.TA2 instanceof ExtendsWildcardType ||
flag){
Logger.getLogger("TypeinferenceResults").error("remove", Section.CODEGEN);
typeReconstructions.remove(i);
i--;
limit--;
flag = true;
}
}
}
this.typeReconstructions = typeReconstructions;
}
public Type getTypeOfPlaceholder(TypePlaceholder typePlaceholder, Menge<TypePlaceholder> toOneOfTheseTypes) {
return typeReconstructions.get(typeReconstructionSetIndex).getTypeOfPlaceholder(typePlaceholder, toOneOfTheseTypes);
}
public Type getTypeOfPlaceholder(TypePlaceholder typePlaceholder) {
return getTypeOfPlaceholder(typePlaceholder, null);
}
public Menge<TypeinferenceResultSet> getTypeReconstructions() {
return typeReconstructions;
}
public void setTypeReconstructionSetIndex(Integer typeReconstructionSetIndex) {
this.typeReconstructionSetIndex = typeReconstructionSetIndex;
}
public List<Integer> getTypeReconstructionSetIndexList(Method method, ClassGenerator cg) {
Menge<FormalParameter> parameters = method.parameterlist.formalparameter;
Menge<TypePlaceholder> typePlaceholders = new Menge<>();
List<Integer> result = new LinkedList<>();
Menge<Type[]> types = new Menge<>();
for(FormalParameter parameter: parameters){
if(parameter.getType() instanceof TypePlaceholder){
typePlaceholders.add((TypePlaceholder) parameter.getType());
}
}
for(int i = 0; i < typeReconstructions.size(); i++){
setTypeReconstructionSetIndex(i);
Type[] reconstructionTypes = new Type[typePlaceholders.size()];
for(int t = 0; t < typePlaceholders.size(); t++){
reconstructionTypes[t] = getTypeOfPlaceholder(typePlaceholders.get(t));
}
if(!types.contains(reconstructionTypes, new TypeArrayEqual(cg))){
types.add(reconstructionTypes);
result.add(i);
}
}
return result;
public Menge<TypeinferenceResultSet> getTypeReconstructions(Method method, ClassGenerator cg) {
return typeReconstructions;
}
}
class TypeArrayEqual implements Equal<Type[]>{
private ClassGenerator cg;
public TypeArrayEqual(ClassGenerator cg) {
this.cg = cg;
}
@Override
public boolean equal(Type[] a, Type[] b) {
if(a.length != b.length){
return false;
}
for(int i = 0; i < a.length; i++){
Logger.getLogger("TypeArrayEqual").error(a[i].toString(), Section.CODEGEN);
Logger.getLogger("TypeArrayEqual").error(b[i].toString(), Section.CODEGEN);
if(!a[i].getBytecodeType(cg).equals(b[i].getBytecodeType(cg))){
Logger.getLogger("TypeArrayEqual").error(a[i].toString(), Section.CODEGEN);
Logger.getLogger("TypeArrayEqual").error(b[i].toString(), Section.CODEGEN);
return false;
}
}
return true;
}
}

2
test/bytecode/SingleClassTester.java
View File

@ -38,6 +38,8 @@ public class SingleClassTester {
Menge<ByteCodeResult> bytecode = compiler.generateBytecode(sourceFiles, results);
//System.out.println(bytecode);
ByteCodeResult result = bytecode.firstElement();
JavaClass javaClass = result.getByteCode().getJavaClass();

2
test/bytecode/types/AutoOverloading.jav
View File

@ -1,5 +1,3 @@
import java.util.Vector;
class AutoOverloading{
method2(String p){

18
test/bytecode/types/AutoOverloadingVector.jav Normal file
View File

@ -0,0 +1,18 @@
import java.util.Vector;
class AutoOverloadingVector{
method2(p){
}
method(Vector<String> p){
method2(p.firstElement());
}
method(Vector<Integer> p){
method2(p.firstElement());
}
}

84
test/bytecode/types/AutoOverloadingVectorTest.java Normal file
View File

@ -0,0 +1,84 @@
package bytecode.types;
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 bytecode.SourceFileBytecodeTest;
public class AutoOverloadingVectorTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "AutoOverloadingVector";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
}
@Test
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
@Test
public void testString() {
try{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
File file = new File(rootDirectory);
URL url = file.toURL();
URL[] urls = new URL[]{url};
Class string = classLoader.loadClass("java.lang.String");
Class[] params = new Class[1];
params[0] = string;
Method method = cls.getDeclaredMethod("method2", params);
method.invoke(obj, string.newInstance());
assertTrue(true);
}catch(Exception e){
throw new RuntimeException(e);
}
}
@Test
public void testInteger() {
try{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
File file = new File(rootDirectory);
URL url = file.toURL();
URL[] urls = new URL[]{url};
Integer integer = new Integer(123);
Class[] params = new Class[1];
params[0] = integer.getClass();
Method method = cls.getDeclaredMethod("method2", params);
method.invoke(obj, integer);
assertTrue(true);
}catch(Exception e){
throw new RuntimeException(e);
}
}
}

4
test/bytecode/types/MethodWithTypedVector.jav
View File

@ -4,4 +4,8 @@ class MethodWithTypedVector{
public void method(Vector<String> v) {
}
public void method(Vector<Integer> v) {
}
}