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

Operator unterstützt jetzt auch Double und Float statt nur Integer als Typ

Browse Source
This commit is contained in:
JanUlrich 2014-04-24 12:42:10 +02:00
parent ce61fdf3c7
commit e7db1e7494
5 changed files with 34 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/mycompiler/myoperator/AddOp.java
View File

@ -66,7 +66,7 @@ public abstract class AddOp extends Operator
@Override @Override
public Type getReturnType(TypeAssumptions ass) { public Type getReturnType(RefType inputType, TypeAssumptions ass) {
Type ret = ass.getTypeFor(new RefType("java.lang.Integer",-1)); Type ret = ass.getTypeFor(new RefType("java.lang.Integer",-1));
if(ret == null)throw new DebugException("java.lang.Integer kann nicht aufgelöst werden"); if(ret == null)throw new DebugException("java.lang.Integer kann nicht aufgelöst werden");
return ret; return ret;

8
src/mycompiler/myoperator/LogOp.java
View File

@ -234,10 +234,10 @@ public abstract class LogOp extends Operator
} }
@Override @Override
public Type getReturnType(TypeAssumptions ass) { public Type getReturnType(RefType inputType, TypeAssumptions ass) {
Type ret = ass.getTypeFor(new RefType("java.lang.Boolean",-1)); Type iT = ass.getTypeFor(inputType);
if(ret == null)throw new DebugException("java.lang.Boolean kann nicht aufgelöst werden"); Type ret = getOperatorTypes().get(iT);
return ret; return ret;
} }

11
src/mycompiler/myoperator/MulOp.java
View File

@ -6,10 +6,14 @@ package mycompiler.myoperator;
import java.util.Hashtable; import java.util.Hashtable;
import java.util.Iterator; import java.util.Iterator;
import java.util.Vector; import java.util.Vector;
import typinferenz.assumptions.TypeAssumptions;
import typinferenz.exceptions.DebugException;
import mycompiler.myexception.CTypeReconstructionException; import mycompiler.myexception.CTypeReconstructionException;
import mycompiler.mystatement.Binary; import mycompiler.mystatement.Binary;
import mycompiler.mytype.Pair; import mycompiler.mytype.Pair;
import mycompiler.mytype.RefType; import mycompiler.mytype.RefType;
import mycompiler.mytype.Type;
import mycompiler.mytypereconstruction.CSupportData; import mycompiler.mytypereconstruction.CSupportData;
import mycompiler.mytypereconstruction.CTriple; import mycompiler.mytypereconstruction.CTriple;
import mycompiler.mytypereconstruction.set.CSubstitutionSet; import mycompiler.mytypereconstruction.set.CSubstitutionSet;
@ -43,6 +47,13 @@ public abstract class MulOp extends Operator
return types; return types;
} }
@Override
public Type getReturnType(RefType inputType, TypeAssumptions ass) {
Type iT = ass.getTypeFor(inputType);
Type ret = getOperatorTypes().get(iT);
return ret;
}
} }

17
src/mycompiler/myoperator/Operator.java
View File

@ -9,6 +9,7 @@ import java.util.Vector;
import typinferenz.ConstraintsSet; import typinferenz.ConstraintsSet;
import typinferenz.SingleConstraint; import typinferenz.SingleConstraint;
import typinferenz.assumptions.TypeAssumptions; import typinferenz.assumptions.TypeAssumptions;
import typinferenz.exceptions.TypeinferenceException;
import mycompiler.IItemWithOffset; import mycompiler.IItemWithOffset;
import mycompiler.mybytecode.ClassFile; import mycompiler.mybytecode.ClassFile;
import mycompiler.mybytecode.CodeAttribute; import mycompiler.mybytecode.CodeAttribute;
@ -124,12 +125,22 @@ public abstract class Operator implements IItemWithOffset
*/ */
public ConstraintsSet TYPEExpr(Expr expr1, Expr expr2, TypeAssumptions ass) { public ConstraintsSet TYPEExpr(Expr expr1, Expr expr2, TypeAssumptions ass) {
ConstraintsSet ret = new ConstraintsSet(); ConstraintsSet ret = new ConstraintsSet();
ret.add(new SingleConstraint(expr1.getType(), this.getReturnType(ass))); Type expr1Type = expr1.getType();
ret.add(new SingleConstraint(expr2.getType(), this.getReturnType(ass))); if(!(expr1Type instanceof RefType))throw new TypeinferenceException("Nicht erlaubter Typ", this);
Type expr2Type = expr1.getType();
if(!(expr2Type instanceof RefType))throw new TypeinferenceException("Nicht erlaubter Typ", this);
Type expr1RetType = this.getReturnType((RefType) expr1Type, ass);
if(expr1RetType == null)throw new TypeinferenceException("Nicht erlaubter Typ "+expr1Type, this);
Type expr2RetType = this.getReturnType((RefType) expr2Type, ass);
if(expr2RetType == null)throw new TypeinferenceException("Nicht erlaubter Typ "+expr2Type, this);
ret.add(new SingleConstraint(expr1Type, expr1RetType));
ret.add(new SingleConstraint(expr2Type, expr2RetType));
return ret; return ret;
} }
public abstract Type getReturnType(TypeAssumptions ass); public abstract Type getReturnType(RefType inputType, TypeAssumptions ass);
} }
// ino.end // ino.end

8
src/mycompiler/myoperator/RelOp.java
View File

@ -57,11 +57,11 @@ public abstract class RelOp extends Operator
} }
@Override @Override
public Type getReturnType(TypeAssumptions ass){ public Type getReturnType(RefType inputType, TypeAssumptions ass) {
Type ret = ass.getTypeFor(new RefType("java.lang.Boolean",-1)); Type iT = ass.getTypeFor(inputType);
if(ret == null)throw new DebugException("java.lang.Boolean kann nicht aufgelöst werden"); Type ret = getOperatorTypes().get(iT);
return ret; return ret;
} }
} }
// ino.end // ino.end