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

Fehler beseitigt. wandleRefType2GenericVariables überarbeitet. getChildren()-Methode für alle Statements implementiert

Browse Source
This commit is contained in:
JanUlrich 2014-03-27 16:43:07 +01:00
parent b6e2d75174
commit 9784a10f84
30 changed files with 7905 additions and 7778 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
bin/mycompiler/myparser/JavaParser.jay
View File

@ -313,7 +313,8 @@ public Vector<Pair> testPair = new Vector<Pair>();
%type <Statement> explicitconstructorinvocation
%type <Method> staticinitializer
%type <CastExpr> castexpression
%type <ParaList> paralist parameter
%type <ParaList> paralist
%type <Vector> typelist parameter
%type <WildcardType> wildcardparameter
%left ','
%%
@ -785,21 +786,34 @@ classbodydeclaration : classmemberdeclaration
classorinterfacetype : simplename parameter
{
if ($2 != null) {
$1.set_ParaList($2.get_ParaList());
//$1.set_ParaList($2.get_ParaList());
$1.set_ParaList($2);//Änderung von Andreas Stadelmeier. Type statt GenericVarType
/* otth: originale (also diese) Parameterliste retten */
((UsedId)$1).vParaOrg = new Vector<Type>( $2.get_ParaList() );
//((UsedId)$1).vParaOrg = new Vector<Type>( $2.get_ParaList() );
}
$$=$1;
}
typelist : type
{
Vector<Type> tl = new Vector<Type>();
tl.add($1);
$$ = tl;
}
| typelist ',' type
{
$1.add($3);
$$=$1;
}
/* PL 05-07-28 erg<72>nzt, weil jeder classorinterfacetype auch parametrisiert sein kann */
//TODO: Das hier ist möglicherweise falsch. Ein Typ hat keine parameterliste, nur eine Liste von RefTypes
parameter : { $$ = null; }
| '<'paralist'>'
| '<'typelist'>'//'<'paralist'>'//typelist statt
{
$$ = $2;
}
interfacememberdeclaration : constantdeclaration
{
// SCJU: Interfaces, Spezialform Konstantendef.

20
src/mycompiler/myclass/Class.java
View File

@ -69,7 +69,7 @@ import typinferenz.UndConstraint;
import typinferenz.FunN;
import typinferenz.assumptions.TypeAssumptions;
import typinferenz.exceptions.TypinferenzException;
import typinferenz.*;
// ino.class.Class.23010.declaration
@ -953,8 +953,10 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface
// ino.end
// ino.method.wandleRefTypeAttributes2GenericAttributes.23128.body
{
for(Field f : this.getFields()){
f.wandleRefTypeAttributes2GenericAttributes(paralist);
}
/*
Vector fieldsAndMethods=this.getFields();
// Alle Methoden und Instanzvariablen durchgehen
@ -965,7 +967,7 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface
Method method=(Method)fieldsAndMethods.get(i);
method.wandleRefTypeAttributes2GenericAttributes(paralist);
}// Ist es eine InstanzVariable?
/*
*//*
else if(fieldsAndMethods.get(i) instanceof InstVarDecl){
InstVarDecl instVar=(InstVarDecl)fieldsAndMethods.get(i);
Type type=instVar.getType();
@ -976,8 +978,9 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface
instVar.setType(pendant);
}
}
}*/
}
}
}*/
}
// ino.end
@ -1302,8 +1305,11 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface
Constructor standardKonstruktor = new Constructor(Method.createEmptyMethod(this.getName(), this));
this.addField(standardKonstruktor);
}
//Als RefType geparste Generische Variablen umwandeln:
this.wandleRefTypeAttributes2GenericAttributes();
}
@Override
public SyntaxTreeNode getParent() {
return this;

58
src/mycompiler/myclass/Constructor.java
View File

@ -324,3 +324,61 @@ public class Constructor extends Method {
}
/*
// ino.class.Constructor.23267.declaration
public class Constructor_Backup extends Method
// ino.end
// ino.class.Constructor.23267.body
{
// ino.method.Constructor.23271.definition
public Constructor_Backup()
// ino.end
// ino.method.Constructor.23271.body
{
this.setParameterList(null);
// #JB# 04.06.2005
// ###########################################################
DeclId decl = new DeclId();
decl.set_Name("<init>");
this.set_DeclId(decl);
// ###########################################################
}
// ino.end
// ino.method.get_codegen_Param_Type.23274.definition
public String get_codegen_Param_Type(Vector paralist)
// ino.end
// ino.method.get_codegen_Param_Type.23274.body
{
String ret = new String();
if(this.getParameterList() == null)
{
ret += "()";
}
else
{
ret += this.getParameterList().get_codegen_ParameterList(paralist);
}
ret += "V";
return ret;
}
// ino.end
// ino.method.codegen.23277.definition
public void codegen(ClassFile classfile, Vector paralist)
throws JVMCodeException
// ino.end
// ino.method.codegen.23277.body
{
classfile.set_constructor_founded(true);
classfile.add_method("<init>", this.get_codegen_Param_Type(paralist), this.getParameterList(), null, get_Block(), declid.firstElement().get_access_flags(), paralist, false);
}
// ino.end
}
*/

79
src/mycompiler/myclass/Constructor_Backup.java
View File

@ -1,79 +0,0 @@
// ino.module.Constructor.8557.package
package mycompiler.myclass;
// ino.end
// ino.module.Constructor.8557.import
import java.util.Iterator;
import java.util.Vector;
import typinferenz.ConstraintsSet;
import typinferenz.assumptions.TypeAssumptions;
import mycompiler.mybytecode.ClassFile;
import mycompiler.myexception.JVMCodeException;
// ino.end
import mycompiler.mytype.TypePlaceholder;
import mycompiler.mytypereconstruction.set.CTypeAssumptionSet;
import mycompiler.mytypereconstruction.typeassumption.CInstVarTypeAssumption;
import mycompiler.mytypereconstruction.typeassumption.CLocalVarTypeAssumption;
import mycompiler.mytypereconstruction.typeassumption.CMethodTypeAssumption;
import mycompiler.mytypereconstruction.typeassumption.CParaTypeAssumption;
import mycompiler.mytypereconstruction.typeassumption.CTypeAssumption;
// ino.class.Constructor.23267.declaration
public class Constructor_Backup extends Method
// ino.end
// ino.class.Constructor.23267.body
{
// ino.method.Constructor.23271.definition
public Constructor_Backup()
// ino.end
// ino.method.Constructor.23271.body
{
this.setParameterList(null);
// #JB# 04.06.2005
// ###########################################################
DeclId decl = new DeclId();
decl.set_Name("<init>");
this.set_DeclId(decl);
// ###########################################################
}
// ino.end
// ino.method.get_codegen_Param_Type.23274.definition
public String get_codegen_Param_Type(Vector paralist)
// ino.end
// ino.method.get_codegen_Param_Type.23274.body
{
String ret = new String();
if(this.getParameterList() == null)
{
ret += "()";
}
else
{
ret += this.getParameterList().get_codegen_ParameterList(paralist);
}
ret += "V";
return ret;
}
// ino.end
// ino.method.codegen.23277.definition
public void codegen(ClassFile classfile, Vector paralist)
throws JVMCodeException
// ino.end
// ino.method.codegen.23277.body
{
classfile.set_constructor_founded(true);
classfile.add_method("<init>", this.get_codegen_Param_Type(paralist), this.getParameterList(), null, get_Block(), declid.firstElement().get_access_flags(), paralist, false);
}
// ino.end
}
// ino.end

9
src/mycompiler/myclass/Field.java
View File

@ -5,6 +5,7 @@ import java.util.Vector;
import mycompiler.SyntaxTreeNode;
import mycompiler.mybytecode.ClassFile;
import mycompiler.myexception.JVMCodeException;
import mycompiler.mytype.GenericTypeVar;
import mycompiler.mytype.Type;
import mycompiler.mytype.TypePlaceholder;
import mycompiler.mytypereconstruction.replacementlistener.CReplaceTypeEvent;
@ -104,4 +105,12 @@ public abstract class Field extends SyntaxTreeNode implements TypeInsertable, Ty
return new TypeInsertPoint(tph, this, resultSet.getTypeEqualTo(tph), resultSet);
}
public void wandleRefTypeAttributes2GenericAttributes(Vector<Type> paralist){
// Zuerst Returntype untersuchen
Type type=getType();
GenericTypeVar pendantReturnType=ClassHelper.findGenericType(type, paralist,new Vector<GenericTypeVar>());
if(pendantReturnType!=null){ //Wenn generisch, dann modifizieren
setType(pendantReturnType);
}
}
}

7
src/mycompiler/myclass/FieldDeclaration.java
View File

@ -14,6 +14,7 @@ import mycompiler.SyntaxTreeNode;
import mycompiler.mybytecode.ClassFile;
import mycompiler.myexception.JVMCodeException;
import mycompiler.mystatement.Expr;
import mycompiler.mytype.GenericTypeVar;
import mycompiler.mytype.Type;
import mycompiler.mytype.TypePlaceholder;
import mycompiler.mytypereconstruction.replacementlistener.CReplaceTypeEvent;
@ -127,6 +128,10 @@ public class FieldDeclaration extends Field{
return ret;
}
@Override
public void wandleRefTypeAttributes2GenericAttributes(Vector<Type> paralist){
super.wandleRefTypeAttributes2GenericAttributes(paralist);
if(this.getWert()!=null)this.getWert().wandleRefTypeAttributes2GenericAttributes(paralist, new Vector<GenericTypeVar>()); //FieldDeclaration hat keine Generischen Variablen, daher leere Liste übergeben
}
}

6
src/mycompiler/myclass/Method.java
View File

@ -497,11 +497,9 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
{
return isAbstract;
}
// ino.end
// ino.method.wandleRefTypeAttributes2GenericAttributes.23614.definition
@Override
public void wandleRefTypeAttributes2GenericAttributes(Vector<Type> paralist)
// ino.end
// ino.method.wandleRefTypeAttributes2GenericAttributes.23614.body
{
// Zuerst Returntype untersuchen
Type returnType=getType();

2959
src/mycompiler/myparser/JavaParser.java
View File

File diff suppressed because it is too large Load Diff

26
src/mycompiler/myparser/JavaParser.jay
View File

@ -313,7 +313,8 @@ public Vector<Pair> testPair = new Vector<Pair>();
%type <Statement> explicitconstructorinvocation
%type <Method> staticinitializer
%type <CastExpr> castexpression
%type <ParaList> paralist parameter
%type <ParaList> paralist
%type <Vector> typelist parameter
%type <WildcardType> wildcardparameter
%left ','
%%
@ -785,21 +786,34 @@ classbodydeclaration : classmemberdeclaration
classorinterfacetype : simplename parameter
{
if ($2 != null) {
$1.set_ParaList($2.get_ParaList());
//$1.set_ParaList($2.get_ParaList());
$1.set_ParaList($2);//Änderung von Andreas Stadelmeier. Type statt GenericVarType
/* otth: originale (also diese) Parameterliste retten */
((UsedId)$1).vParaOrg = new Vector<Type>( $2.get_ParaList() );
//((UsedId)$1).vParaOrg = new Vector<Type>( $2.get_ParaList() );
}
$$=$1;
}
typelist : type
{
Vector<Type> tl = new Vector<Type>();
tl.add($1);
$$ = tl;
}
| typelist ',' type
{
$1.add($3);
$$=$1;
}
/* PL 05-07-28 erg<72>nzt, weil jeder classorinterfacetype auch parametrisiert sein kann */
//TODO: Das hier ist möglicherweise falsch. Ein Typ hat keine parameterliste, nur eine Liste von RefTypes
parameter : { $$ = null; }
| '<'paralist'>'
| '<'typelist'>'//'<'paralist'>'//typelist statt
{
$$ = $2;
}
interfacememberdeclaration : constantdeclaration
{
// SCJU: Interfaces, Spezialform Konstantendef.

11
src/mycompiler/mystatement/CastExpr.java
View File

@ -6,6 +6,7 @@ import java.util.Hashtable;
import java.util.Iterator;
import java.util.Vector;
import mycompiler.SyntaxTreeNode;
import mycompiler.mybytecode.ClassFile;
import mycompiler.mybytecode.CodeAttribute;
import mycompiler.mybytecode.JVMCode;
@ -27,6 +28,7 @@ import org.apache.log4j.Logger;
// ino.end
import typinferenz.ConstraintsSet;
import typinferenz.JavaCodeResult;
import typinferenz.ResultSet;
@ -149,6 +151,15 @@ public class CastExpr extends UnaryExpr
return new JavaCodeResult("(("+this.usedid+")").attach(this.expr.printJavaCode(resultSet)).attach(")");
}
@Override
public Vector<SyntaxTreeNode> getChildren() {
Vector<SyntaxTreeNode> ret = new Vector<SyntaxTreeNode>();
ret.add(this.expr);
return ret;
}
}
// ino.end

5
src/mycompiler/mystatement/EmptyStmt.java
View File

@ -114,5 +114,10 @@ public class EmptyStmt extends Statement
return new JavaCodeResult("");
}
@Override
public Vector<SyntaxTreeNode> getChildren() {
return new Vector<SyntaxTreeNode>();
}
}
// ino.end

9
src/mycompiler/mystatement/InstVar.java
View File

@ -7,6 +7,7 @@ import java.util.Hashtable;
import java.util.Iterator;
import java.util.Vector;
import mycompiler.SyntaxTreeNode;
import mycompiler.mybytecode.ClassFile;
import mycompiler.mybytecode.CodeAttribute;
import mycompiler.mybytecode.JVMCode;
@ -34,6 +35,7 @@ import org.apache.log4j.Logger;
// ino.end
import typinferenz.ConstraintsSet;
import typinferenz.FreshTypeVariable;
import typinferenz.JavaCodeResult;
@ -274,5 +276,12 @@ public class InstVar extends Expr
public JavaCodeResult printJavaCode(ResultSet resultSet) {
return new JavaCodeResult().attach(this.expr.printJavaCode(resultSet)).attach("."+this.usedid.get_Name_1Element());
}
@Override
public Vector<SyntaxTreeNode> getChildren() {
Vector<SyntaxTreeNode> ret = new Vector<SyntaxTreeNode>();
ret.add(this.expr);
return ret;
}
}
// ino.end

9
src/mycompiler/mystatement/InstanceOf.java
View File

@ -6,6 +6,7 @@ import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
import mycompiler.SyntaxTreeNode;
import mycompiler.mybytecode.ClassFile;
import mycompiler.mybytecode.CodeAttribute;
import mycompiler.mybytecode.JVMCode;
@ -27,6 +28,7 @@ import org.apache.log4j.Logger;
// ino.end
import typinferenz.ConstraintsSet;
import typinferenz.JavaCodeResult;
import typinferenz.ResultSet;
@ -150,6 +152,13 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
// TODO Auto-generated method stub
return null;
}
@Override
public Vector<SyntaxTreeNode> getChildren() {
Vector<SyntaxTreeNode> ret = new Vector<SyntaxTreeNode>();
ret.add(this.expr);
return ret;
}
}

25
src/mycompiler/mystatement/LambdaExpression.java
View File

@ -17,6 +17,7 @@ import mycompiler.SyntaxTreeNode;
import mycompiler.mybytecode.ClassFile;
import mycompiler.mybytecode.CodeAttribute;
import mycompiler.myclass.Class;
import mycompiler.myclass.ClassHelper;
import mycompiler.myclass.FormalParameter;
import mycompiler.myclass.Method;
import mycompiler.myclass.ParameterList;
@ -81,8 +82,28 @@ public class LambdaExpression extends Expr{
public void wandleRefTypeAttributes2GenericAttributes(
Vector<Type> paralist,
Vector<GenericTypeVar> genericMethodParameters) {
// TODO Auto-generated method stub
Block block = this.method_body;
// Zuerst Returntype untersuchen
Type returnType=getType();
GenericTypeVar pendantReturnType=ClassHelper.findGenericType(returnType, paralist,genericMethodParameters);
if(pendantReturnType!=null){ //Wenn generisch, dann modifizieren
setType(pendantReturnType);
}
// Dann parameterlist untersuchen
for(FormalParameter fp : params){
Type fpType=fp.getType();
// Nur wenn es sich um ein RefType-Field handelt
GenericTypeVar pendantPara=ClassHelper.findGenericType(fpType,paralist,genericMethodParameters);
if(pendantPara!=null){ //Wenn generisch, dann modifizieren
fp.setType(pendantPara);
}
}
// Zuletzt alle Lokalen Variablendeklarationen durchgehen
if(block!=null){
block.wandleRefTypeAttributes2GenericAttributes(paralist,genericMethodParameters);
}
}
@Override

8
src/mycompiler/mystatement/LocalVarDecl.java
View File

@ -39,10 +39,12 @@ import org.apache.log4j.Logger;
import typinferenz.ConstraintsSet;
import typinferenz.FreshTypeVariable;
import typinferenz.JavaCodeResult;
import typinferenz.ResultSet;
import typinferenz.TypeInsertPoint;
import typinferenz.TypeInsertable;
import typinferenz.assumptions.LocalVarAssumption;
import typinferenz.assumptions.TypeAssumptions;
@ -493,5 +495,11 @@ public class LocalVarDecl extends Statement implements TypeInsertable
Vector<SyntaxTreeNode> ret = new Vector<SyntaxTreeNode>();
return ret;
}
@Override
public TypeInsertPoint createTypeInsertPoint(TypePlaceholder tph,
ResultSet resultSet) {
return new TypeInsertPoint(tph, this, resultSet.getTypeEqualTo(tph),resultSet);
}
}
// ino.end

2
src/mycompiler/mystatement/MethodCall.java
View File

@ -236,7 +236,7 @@ public class MethodCall extends Expr
ParameterList pl=new ParameterList();
for(int i=0;i<paraAssumptions.size();i++){
CParaTypeAssumption paraassumtion=paraAssumptions.elementAt(i);
FormalParameter fp=new FormalParameter();
FormalParameter fp=new FormalParameter(new DeclId());
fp.setType(paraassumtion.getAssumedType());
parameterVector.addElement(fp);
}

11
src/mycompiler/mystatement/NegativeExpr.java
View File

@ -6,6 +6,7 @@ import java.util.Hashtable;
import java.util.Iterator;
import java.util.Vector;
import mycompiler.SyntaxTreeNode;
import mycompiler.mybytecode.ClassFile;
import mycompiler.mybytecode.CodeAttribute;
import mycompiler.myclass.Class;
@ -30,6 +31,7 @@ import org.apache.log4j.Logger;
// ino.end
import typinferenz.ConstraintsSet;
import typinferenz.JavaCodeResult;
import typinferenz.ResultSet;
@ -139,10 +141,17 @@ public class NegativeExpr extends UnaryExpr
}
@Override
public JavaCodeResult printJavaCode(ResultSet resultSet) {
public JavaCodeResult printJavaCode(ResultSet resultSet) {
// TODO Auto-generated method stub
return null;
}
@Override
public Vector<SyntaxTreeNode> getChildren() {
Vector<SyntaxTreeNode> ret = new Vector<SyntaxTreeNode>();
ret.add(this.expr);
return ret;
}
}
// ino.end

9
src/mycompiler/mystatement/NewArray.java
View File

@ -5,6 +5,7 @@ package mycompiler.mystatement;
import java.util.Hashtable;
import java.util.Vector;
import mycompiler.SyntaxTreeNode;
import mycompiler.mybytecode.ClassFile;
import mycompiler.mybytecode.CodeAttribute;
import mycompiler.mybytecode.JVMCode;
@ -23,6 +24,7 @@ import org.apache.log4j.Logger;
// ino.end
import typinferenz.ConstraintsSet;
import typinferenz.JavaCodeResult;
import typinferenz.ResultSet;
@ -202,5 +204,12 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
return null;
}
@Override
public Vector<SyntaxTreeNode> getChildren() {
Vector<SyntaxTreeNode> ret = new Vector<SyntaxTreeNode>();
ret.addAll(this.expr);
return ret;
}
}
// ino.end

9
src/mycompiler/mystatement/NotExpr.java
View File

@ -6,6 +6,7 @@ import java.util.Hashtable;
import java.util.Iterator;
import java.util.Vector;
import mycompiler.SyntaxTreeNode;
import mycompiler.mybytecode.ClassFile;
import mycompiler.mybytecode.CodeAttribute;
import mycompiler.myclass.Class;
@ -29,6 +30,7 @@ import org.apache.log4j.Logger;
// ino.end
import typinferenz.ConstraintsSet;
import typinferenz.JavaCodeResult;
import typinferenz.ResultSet;
@ -163,5 +165,12 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
return null;
}
@Override
public Vector<SyntaxTreeNode> getChildren() {
Vector<SyntaxTreeNode> ret = new Vector<SyntaxTreeNode>();
ret.add(this.expr);
return ret;
}
}
// ino.end

9
src/mycompiler/mystatement/PositivExpr.java
View File

@ -5,6 +5,7 @@ package mycompiler.mystatement;
import java.util.Hashtable;
import java.util.Vector;
import mycompiler.SyntaxTreeNode;
import mycompiler.mybytecode.ClassFile;
import mycompiler.mybytecode.CodeAttribute;
import mycompiler.myclass.Class;
@ -22,6 +23,7 @@ import org.apache.log4j.Logger;
// ino.end
import typinferenz.ConstraintsSet;
import typinferenz.JavaCodeResult;
import typinferenz.ResultSet;
@ -143,5 +145,12 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
return null;
}
@Override
public Vector<SyntaxTreeNode> getChildren() {
Vector<SyntaxTreeNode> ret = new Vector<SyntaxTreeNode>();
ret.add(this.expr);
return ret;
}
}
// ino.end

9
src/mycompiler/mystatement/PostDecExpr.java
View File

@ -6,6 +6,7 @@ import java.util.Hashtable;
import java.util.Iterator;
import java.util.Vector;
import mycompiler.SyntaxTreeNode;
import mycompiler.mybytecode.ClassFile;
import mycompiler.mybytecode.CodeAttribute;
import mycompiler.mybytecode.JVMCode;
@ -31,6 +32,7 @@ import org.apache.log4j.Logger;
// ino.end
import typinferenz.ConstraintsSet;
import typinferenz.JavaCodeResult;
import typinferenz.ResultSet;
@ -182,5 +184,12 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
return null;
}
@Override
public Vector<SyntaxTreeNode> getChildren() {
Vector<SyntaxTreeNode> ret = new Vector<SyntaxTreeNode>();
ret.add(this.expr);
return ret;
}
}
// ino.end

9
src/mycompiler/mystatement/PostIncExpr.java
View File

@ -6,6 +6,7 @@ import java.util.Hashtable;
import java.util.Iterator;
import java.util.Vector;
import mycompiler.SyntaxTreeNode;
import mycompiler.mybytecode.ClassFile;
import mycompiler.mybytecode.CodeAttribute;
import mycompiler.mybytecode.JVMCode;
@ -31,6 +32,7 @@ import org.apache.log4j.Logger;
// ino.end
import typinferenz.ConstraintsSet;
import typinferenz.JavaCodeResult;
import typinferenz.ResultSet;
@ -182,5 +184,12 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
return null;
}
@Override
public Vector<SyntaxTreeNode> getChildren() {
Vector<SyntaxTreeNode> ret = new Vector<SyntaxTreeNode>();
ret.add(this.expr);
return ret;
}
}
// ino.end

10
src/mycompiler/mystatement/PreDecExpr.java
View File

@ -6,6 +6,7 @@ import java.util.Hashtable;
import java.util.Iterator;
import java.util.Vector;
import mycompiler.SyntaxTreeNode;
import mycompiler.mybytecode.ClassFile;
import mycompiler.mybytecode.CodeAttribute;
import mycompiler.mybytecode.JVMCode;
@ -31,6 +32,7 @@ import org.apache.log4j.Logger;
// ino.end
import typinferenz.ConstraintsSet;
import typinferenz.JavaCodeResult;
import typinferenz.ResultSet;
@ -175,10 +177,16 @@ public class PreDecExpr extends UnaryExpr
return null;
}
@Override
public JavaCodeResult printJavaCode(ResultSet resultSet) {
public JavaCodeResult printJavaCode(ResultSet resultSet) {
// TODO Auto-generated method stub
return null;
}
@Override
public Vector<SyntaxTreeNode> getChildren() {
Vector<SyntaxTreeNode> ret = new Vector<SyntaxTreeNode>();
ret.add(this.expr);
return ret;
}
}
// ino.end

9
src/mycompiler/mystatement/PreIncExpr.java
View File

@ -6,6 +6,7 @@ import java.util.Hashtable;
import java.util.Iterator;
import java.util.Vector;
import mycompiler.SyntaxTreeNode;
import mycompiler.mybytecode.ClassFile;
import mycompiler.mybytecode.CodeAttribute;
import mycompiler.mybytecode.JVMCode;
@ -31,6 +32,7 @@ import org.apache.log4j.Logger;
// ino.end
import typinferenz.ConstraintsSet;
import typinferenz.JavaCodeResult;
import typinferenz.ResultSet;
@ -183,5 +185,12 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
return null;
}
@Override
public Vector<SyntaxTreeNode> getChildren() {
Vector<SyntaxTreeNode> ret = new Vector<SyntaxTreeNode>();
ret.add(this.expr);
return ret;
}
}
// ino.end

3
src/typinferenz/FunN.java
View File

@ -142,6 +142,7 @@ public class FunN extends RefType implements ITypeReplacementListener{
}
*/
/*
@Override
public JavaCodeResult printJavaCode(ResultSet resultSet){
//String ret = super.printJavaCode(resultSet) + (T!=null ? this.T.size() : 0) +"<";
@ -156,7 +157,7 @@ public class FunN extends RefType implements ITypeReplacementListener{
//ret = ret.substring(0, ret.length()-2);
return ret.attach(">");
}
*/
/**
* Die Clone-Methode von RefType darf von FunN NICHT überschrieben werden.
@Override

12
src/typinferenz/assumptions/TypeAssumptions.java
View File

@ -265,7 +265,15 @@ public class TypeAssumptions {
return new RefType(thisClassName, 0);
}
/**
* Prüft einen Typ auf das vorhandensein in den BasicAssumptions.
* Dabei werden alle Konstruktoren nach diesem Typ durchsucht. Denn jede Klasse hat einen Konstruktor und der muss in den TypeAssumptions vorhanden sein.
* @param t
* @return
public Type validateType(Type t){
return null;
}
*/
}

26
test/mycompiler/test/lambda/testResults/LambdaTest.log
View File

@ -1,12 +1,26 @@
Class DEBUG [Typeinference] Erstellte Assumptions: this: TestMethodCallMethod Assumptions:
[MethodAssumption: TPH B null { [null Return null (this(null))], MethodAssumption: TPH C null { [null Return null (null.getSomething( [ ]))], MethodAssumption: void void { [(var = null (null.getSomethingMore( [ ])))], MethodAssumption: TPH B null { [null Return null (this(null))], MethodAssumption: TPH C null { [null Return null (null.getSomething( [ ]))], MethodAssumption: void void { [(var = null (null.getSomethingMore( [ ])))], MethodAssumption: TPH E , MethodAssumption: TPH F , MethodAssumption: TPH H , MethodAssumption: TPH K , MethodAssumption: TPH O , MethodAssumption: TPH T , MethodAssumption: TPH B null { [null Return null (this(null))], MethodAssumption: TPH C null { [null Return null (null.getSomething( [ ]))], MethodAssumption: void void { [(var = null (null.getSomethingMore( [ ])))], MethodAssumption: TPH B null { [null Return null (this(null))], MethodAssumption: TPH C null { [null Return null (null.getSomething( [ ]))], MethodAssumption: void void { [(var = null (null.getSomethingMore( [ ])))]]
Class DEBUG [Typeinference] Erstellte Assumptions: this: MatrixMethod Assumptions:
[MethodAssumption: GTV R , MethodAssumption: GTV R , MethodAssumption: GTV R , MethodAssumption: GTV R , MethodAssumption: GTV R , MethodAssumption: GTV R ]
FieldVar Assumptions:
[typinferenz.assumptions.FieldAssumption@6744719c, typinferenz.assumptions.FieldAssumption@3e7eedbb, typinferenz.assumptions.FieldAssumption@6744719c, typinferenz.assumptions.FieldAssumption@3e7eedbb]
[FieldAssumption: TPH A op, FieldAssumption: TPH A op, FieldAssumption: TPH A op, FieldAssumption: TPH A op]
LocalVar Assumptions:
[]
Parameter Assumptions:
[]
Block DEBUG [Typeinference] Prozessing statement: null Return null (this(null))
Block DEBUG [Typeinference] Prozessing statement: TPH Z Return TestMethodCall (this(null))
Block DEBUG [Typeinference] Prozessing statement: null Return null (null.getSomething( [ ]))
Block DEBUG [Typeinference] Prozessing statement: null Return null (( [ f, ]) -> null { [null Return null (f.apply( [ null (this(null)), m, ]))])
Block DEBUG [Typeinference] Prozessing statement: null Return null (f.apply( [ null (this(null)), m, ]))
Block DEBUG [Typeinference] Prozessing statement: TPH H Return TPH G (f: TPH E.apply( [ Matrix (this(null)), m: TPH C, ]))
Block DEBUG [Typeinference] Prozessing statement: TPH I Return TPH F (( [ TPH E f, ]) -> TPH H { [TPH H Return TPH G (f: TPH E.apply( [ Matrix (this(null)), m: TPH C, ]))])
Class DEBUG [Typeinference] Erstellte Constraints: TPH A < TPH A
[[(R <. TPH G), (Matrix <. T1), (TPH C <. T2), (TPH E <. Fun2< GTV R, GTV T1, GTV T2 >), ]| ]
TPH G < TPH H
Fun1< TPH H, TPH E > < TPH F
TPH F < TPH I
Fun1< TPH I, TPH C > < TPH D
TPH D < TPH A
SourceFile DEBUG [Typeinference] Karthesisches Produkt der Constraints: [[(TPH A <. TPH A), (R <. TPH G), (Matrix <. T1), (TPH C <. T2), (TPH E <. Fun2< GTV R, GTV T1, GTV T2 >), (TPH G <. TPH H), (Fun1< TPH H, TPH E > <. TPH F), (TPH F <. TPH I), (Fun1< TPH I, TPH C > <. TPH D), (TPH D <. TPH A)]]
SourceFile DEBUG [Typeinference] Unifiziertes Ergebnis: []
SourceFile DEBUG [Typeinference]
JavaFiles:

5
test/plugindevelopment/TypeInsertTests/LambdaTest4.jav Normal file
View File

@ -0,0 +1,5 @@
class LambdaTest{
Fun1<String, String> op = (var) -> {return var;};
}

18
test/plugindevelopment/TypeInsertTests/LambdaTest4.java Normal file
View File

@ -0,0 +1,18 @@
package plugindevelopment.TypeInsertTests;
import java.util.Vector;
import org.junit.Test;
public class LambdaTest4 {
private static final String TEST_FILE = "LambdaTest4.jav";
@Test
public void run(){
Vector<String> mustContain = new Vector<String>();
mustContain.add("String var");
MultipleTypesInsertTester.test(this.TEST_FILE, mustContain);
}
}

12285
tools/y.output
View File

File diff suppressed because it is too large Load Diff