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

Umstellung auf anderen Logger

Browse Source
This commit is contained in:
JanUlrich 2014-11-04 13:47:05 +01:00
parent aeef4aed34
commit 1cb66d4f88
46 changed files with 490 additions and 424 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bin/.gitignore vendored
View File

@ -1,6 +1,6 @@
/bytecode/
/de/ /de/
/mycompiler/ /mycompiler/
/parser/ /parser/
/plugindevelopment/ /plugindevelopment/
/syntaxTree/ /syntaxTree/
/bytecode/

4
src/de/dhbwstuttgart/core/ConsoleInterface.java
View File

@ -6,7 +6,7 @@ import static org.junit.Assert.fail;
import java.util.*; import java.util.*;
import de.dhbwstuttgart.logger.Logger; import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.LoggerConfiguration;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet; import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException; import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
public class ConsoleInterface { public class ConsoleInterface {
@ -20,7 +20,7 @@ public class ConsoleInterface {
for(String file : args){ for(String file : args){
filenames.add(file); filenames.add(file);
} }
Logger.setStandardOutput(null); // sämtliches Logging unterdrücken Logger.setStandardConfiguration(new LoggerConfiguration()); // sämtliches Logging unterdrücken
run(filenames); run(filenames);
} }

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

@ -14,8 +14,7 @@ import java.io.StringReader;
import java.util.Vector; import java.util.Vector;
import de.dhbwstuttgart.logger.Logger; import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.bytecode.ClassFile; import de.dhbwstuttgart.bytecode.ClassFile;
import de.dhbwstuttgart.myexception.CTypeReconstructionException; import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.myexception.JVMCodeException; import de.dhbwstuttgart.myexception.JVMCodeException;
@ -142,7 +141,7 @@ public class MyCompiler implements MyCompilerAPI
* @param className Klassenname der aktuell betrachteten Klasse * @param className Klassenname der aktuell betrachteten Klasse
* @param Parameter Parameter der Superklasse * @param Parameter Parameter der Superklasse
* @param KlassenVektor * @param KlassenVektor
*/
// ino.end // ino.end
// ino.method.wandleGeneric2RefType.21289.definition // ino.method.wandleGeneric2RefType.21289.definition
public static void wandleGeneric2RefType(Vector<Type> Parameter, Vector<Class> KlassenVektor ) public static void wandleGeneric2RefType(Vector<Type> Parameter, Vector<Class> KlassenVektor )
@ -220,7 +219,7 @@ public class MyCompiler implements MyCompilerAPI
} //end for } //end for
} //end wandleGeneric2RefType } //end wandleGeneric2RefType
// ino.end // ino.end
*/
// ino.method.parse.21292.defdescription type=javadoc // ino.method.parse.21292.defdescription type=javadoc
@ -513,14 +512,12 @@ public class MyCompiler implements MyCompilerAPI
// ino.end // ino.end
// ino.method.typeReconstruction.21304.body // ino.method.typeReconstruction.21304.body
{ {
Logger.setStandardOutput(System.out); //TODO: Hier noch das Log-Level richtig setzen (je nachdem ob debugt wird oder nicht)
if(m_AbstractSyntaxTree==null){ if(m_AbstractSyntaxTree==null){
throw new NullPointerException("Es wurde noch kein Abstrakter Syntaxbaum erstellt!"); throw new NullPointerException("Es wurde noch kein Abstrakter Syntaxbaum erstellt!");
} }
inferencelog.info("##########################################"); inferencelog.info("##########################################", Section.TYPEINFERENCE);
inferencelog.info("# TypeReconstruction-Algorithmus - START #"); inferencelog.info("# TypeReconstruction-Algorithmus - START #", Section.TYPEINFERENCE);
inferencelog.info("##########################################\n"); inferencelog.info("##########################################\n", Section.TYPEINFERENCE);
TypeAssumptions globalAssumptions = makeFunNAssumptions(); TypeAssumptions globalAssumptions = makeFunNAssumptions();
Vector<TypeinferenceResultSet> result = new Vector<TypeinferenceResultSet>(); Vector<TypeinferenceResultSet> result = new Vector<TypeinferenceResultSet>();
@ -529,9 +526,9 @@ public class MyCompiler implements MyCompilerAPI
} }
inferencelog.info("#########################################"); inferencelog.info("#########################################", Section.TYPEINFERENCE);
inferencelog.info("# TypeReconstruction-Algorithmus - ENDE #"); inferencelog.info("# TypeReconstruction-Algorithmus - ENDE #", Section.TYPEINFERENCE);
inferencelog.info("#########################################\n"); inferencelog.info("#########################################\n", Section.TYPEINFERENCE);
return result; return result;
} }

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

@ -8,17 +8,21 @@ import java.util.logging.LogRecord;
public class Logger { public class Logger {
private static PrintStream standardOutput; private static LoggerConfiguration standardConfiguration = new LoggerConfiguration();
private static final HashMap<String, Logger> LOGGER_DIRECTORY = new HashMap<>(); private static final HashMap<String, Logger> LOGGER_DIRECTORY = new HashMap<>();
private String name; private String name;
private final java.util.logging.Logger log; private final HashMap<Section, java.util.logging.Logger> logger;
private Logger(String name, PrintStream output) { protected Logger(String name, LoggerConfiguration config) {
this.name = name; this.name = name;
this.log = java.util.logging.Logger.getLogger( name ); this.logger = new HashMap<>();
if(output != null)log.addHandler(new OutputHandler(output)); config.forEach((s,o)->{
log.setLevel(Level.FINE); java.util.logging.Logger log = java.util.logging.Logger.getLogger( name );
log.setLevel(Level.FINE);
log.addHandler(new OutputHandler(o));
logger.put(s, log);
});
} }
/** /**
@ -28,11 +32,7 @@ public class Logger {
* @param section * @param section
*/ */
public void debug(String message, Section section){ public void debug(String message, Section section){
output(message, Level.FINE); output(message, Level.FINE, section);
}
public void debug(String message){
//output(message, Level.FINE);
} }
/** /**
@ -46,14 +46,28 @@ public class Logger {
if(LOGGER_DIRECTORY.containsKey(name)){ if(LOGGER_DIRECTORY.containsKey(name)){
ret = LOGGER_DIRECTORY.get(name); ret = LOGGER_DIRECTORY.get(name);
}else{ }else{
ret = new Logger(name, standardOutput); ret = new Logger(name, standardConfiguration);
LOGGER_DIRECTORY.put(name, ret); LOGGER_DIRECTORY.put(name, ret);
} }
return ret; return ret;
} }
private void output(String msg , Level logLevel){ public static SectionLogger getSectionLogger(String name, Section s) {
log.log(logLevel, msg); Logger ret;
if(LOGGER_DIRECTORY.containsKey(name)){
ret = LOGGER_DIRECTORY.get(name);
}else{
ret = new Logger(name, standardConfiguration);
LOGGER_DIRECTORY.put(name, ret);
}
return new SectionLogger(ret,s);
}
protected void output(String msg , Level logLevel, Section section){
if(logger.containsKey(section)){
java.util.logging.Logger log = logger.get(section);
log.log(logLevel, msg);
}
/* /*
if(output != null){ if(output != null){
output.println(msg); output.println(msg);
@ -63,20 +77,21 @@ public class Logger {
*/ */
} }
public void info(String message) { public void info(String message, Section s) {
output(message, Level.INFO); output(message, Level.INFO, s);
} }
public void error(String message) { public void error(String message, Section s) {
output(message, Level.WARNING); output(message, Level.WARNING, s);
} }
/** /**
* wird hier null übergeben, so wird sämtliches Logging unterdrückt. * wird hier null übergeben, so wird sämtliches Logging unterdrückt.
*/ */
public static void setStandardOutput(PrintStream outputStream) { public static void setStandardConfiguration(LoggerConfiguration config) {
Logger.standardOutput = outputStream; Logger.standardConfiguration = config;
} }
} }
class OutputHandler extends Handler{ class OutputHandler extends Handler{

3
src/de/dhbwstuttgart/logger/Section.java
View File

@ -3,5 +3,6 @@ package de.dhbwstuttgart.logger;
public enum Section { public enum Section {
TYPEINFERENCE, TYPEINFERENCE,
PARSER, PARSER,
CODEGEN; CODEGEN,
UNIFY, FINITECLOSURE;
} }

2
src/de/dhbwstuttgart/myexception/SCClassException.java
View File

@ -60,8 +60,6 @@ public class SCClassException extends Exception
{ {
hilfe=el.nextElement(); hilfe=el.nextElement();
hilfe.fehlerausgabe(); hilfe.fehlerausgabe();
if(el.hasMoreElements())
parserlog.debug("");
} }
} }
// ino.end // ino.end

2
src/de/dhbwstuttgart/myexception/SCExcept.java
View File

@ -68,6 +68,7 @@ public class SCExcept
// ino.end // ino.end
// ino.method.fehlerausgabe.23868.body // ino.method.fehlerausgabe.23868.body
{ {
/*
parserlog.error("Semantik-Check hat einen Fehler gefunden!"); parserlog.error("Semantik-Check hat einen Fehler gefunden!");
parserlog.error("Fehler "+error); parserlog.error("Fehler "+error);
parserlog.error("wurde in"); parserlog.error("wurde in");
@ -78,6 +79,7 @@ public class SCExcept
if(statement!=null) if(statement!=null)
parserlog.error("im Statement "+statement); parserlog.error("im Statement "+statement);
parserlog.error("gefunden."); parserlog.error("gefunden.");
*/
} }
// ino.end // ino.end

2
src/de/dhbwstuttgart/myexception/SCException.java
View File

@ -43,8 +43,6 @@ public class SCException extends Exception
{ {
hilf=el.nextElement(); hilf=el.nextElement();
hilf.fehlerausgabe(); hilf.fehlerausgabe();
if(el.hasMoreElements())
parserlog.debug("");
} }
} }
// ino.end // ino.end

3
src/de/dhbwstuttgart/parser/JavaLexer.java
View File

@ -7,6 +7,7 @@
********************************************/ ********************************************/
// user code: // user code:
package de.dhbwstuttgart.parser; package de.dhbwstuttgart.parser;
import de.dhbwstuttgart.logger.Section;
public class JavaLexer { public class JavaLexer {
@ -1291,7 +1292,7 @@ public class JavaLexer {
case -37: case -37:
break; break;
case 37: case 37:
{de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("Kommentar: "+yytext());} {de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("Kommentar: "+yytext(), Section.PARSER);}
case -38: case -38:
break; break;
case 38: case 38:

3
src/de/dhbwstuttgart/parser/JavaLexer.lex
View File

@ -9,6 +9,7 @@
// user code: // user code:
package de.dhbwstuttgart.parser; package de.dhbwstuttgart.parser;
import de.dhbwstuttgart.logger.Section;
%% %%
%char %char
@ -167,7 +168,7 @@ null {
//">>=" {this.token = new Token(JavaParser.SIGNEDSHIFTRIGHTEQUAL, yytext(), yyline, yychar);return true;} //">>=" {this.token = new Token(JavaParser.SIGNEDSHIFTRIGHTEQUAL, yytext(), yyline, yychar);return true;}
//">>>=" {this.token = new Token(JavaParser.UNSIGNEDSHIFTRIGHTEQUAL, yytext(), yyline, yychar);return true;} //">>>=" {this.token = new Token(JavaParser.UNSIGNEDSHIFTRIGHTEQUAL, yytext(), yyline, yychar);return true;}
{ws}|\n { /* System.out.print(yytext()); */ } {ws}|\n { /* System.out.print(yytext()); */ }
\\.\n {de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("Kommentar: "+yytext());} \\.\n {de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("Kommentar: "+yytext(), Section.PARSER);}
"->" {this.token = new Token(JavaParser.LAMBDAASSIGNMENT, yytext(), yyline, yychar);return true;} "->" {this.token = new Token(JavaParser.LAMBDAASSIGNMENT, yytext(), yyline, yychar);return true;}

617
src/de/dhbwstuttgart/parser/JavaParser.java
View File

File diff suppressed because it is too large Load Diff

41
src/de/dhbwstuttgart/parser/JavaParser.jay
View File

@ -8,6 +8,7 @@ package de.dhbwstuttgart.parser;
import de.dhbwstuttgart.core.AClassOrInterface; import de.dhbwstuttgart.core.AClassOrInterface;
import de.dhbwstuttgart.syntaxtree.Class; import de.dhbwstuttgart.syntaxtree.Class;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.syntaxtree.ImportDeclarations; import de.dhbwstuttgart.syntaxtree.ImportDeclarations;
import de.dhbwstuttgart.syntaxtree.Interface; import de.dhbwstuttgart.syntaxtree.Interface;
import de.dhbwstuttgart.syntaxtree.SourceFile; import de.dhbwstuttgart.syntaxtree.SourceFile;
@ -486,7 +487,7 @@ paralist : IDENTIFIER
pl.getParalist().addElement(new GenericTypeVar($1.getLexem(),null, $1.getOffset())); pl.getParalist().addElement(new GenericTypeVar($1.getLexem(),null, $1.getOffset()));
//pl.getParalist().addElement( new TypePlaceholder($1.getLexem()) ); //pl.getParalist().addElement( new TypePlaceholder($1.getLexem()) );
/* ########################################################### */ /* ########################################################### */
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug( "IDENTIFIER --> Paralist f<>r " + $1.getLexem() + " TV"); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug( "IDENTIFIER --> Paralist f<>r " + $1.getLexem() + " TV", Section.PARSER);
$$ = pl; $$ = pl;
} }
| IDENTIFIER '<' paralist '>' | IDENTIFIER '<' paralist '>'
@ -495,7 +496,7 @@ paralist : IDENTIFIER
RefType t = new RefType( $1.getLexem(),null,$1.getOffset() ); RefType t = new RefType( $1.getLexem(),null,$1.getOffset() );
t.set_ParaList( $3.get_ParaList() ); t.set_ParaList( $3.get_ParaList() );
pl.getParalist().addElement(t); pl.getParalist().addElement(t);
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug( "IDENTIFIER '<' paralist '>' --> Paralist f<>r " + $1.getLexem() + ": RefType"); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug( "IDENTIFIER '<' paralist '>' --> Paralist f<>r " + $1.getLexem() + ": RefType", Section.PARSER);
$$ = pl; $$ = pl;
} }
| wildcardparameter | wildcardparameter
@ -512,8 +513,8 @@ paralist : IDENTIFIER
$1.getParalist().addElement(new GenericTypeVar($3.getLexem(), null,$3.getOffset())); $1.getParalist().addElement(new GenericTypeVar($3.getLexem(), null,$3.getOffset()));
//$1.getParalist().addElement(new TypePlaceholder($3.getLexem())); //$1.getParalist().addElement(new TypePlaceholder($3.getLexem()));
/* ########################################################### */ /* ########################################################### */
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug( "paralist ',' IDENTIFIER --> Paralist f<>r " + $3.getLexem() + ": TV"); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug( "paralist ',' IDENTIFIER --> Paralist f<>r " + $3.getLexem() + ": TV", Section.PARSER);
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug( "paralist: " + $1.getParalist()); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug( "paralist: " + $1.getParalist(), Section.PARSER);
$$=$1; $$=$1;
} }
@ -522,7 +523,7 @@ paralist : IDENTIFIER
RefType t = new RefType( $3.getLexem(),null ,$3.getOffset() ); RefType t = new RefType( $3.getLexem(),null ,$3.getOffset() );
t.set_ParaList( $5.get_ParaList() ); t.set_ParaList( $5.get_ParaList() );
$1.getParalist().addElement(t); $1.getParalist().addElement(t);
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug( "paralist ',' IDENTIFIER '<' paralist '>' --> Paralist f<>r " + $3.getLexem() + ": RefType"); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug( "paralist ',' IDENTIFIER '<' paralist '>' --> Paralist f<>r " + $3.getLexem() + ": RefType", Section.PARSER);
$$=$1; $$=$1;
} }
| paralist ',' wildcardparameter | paralist ',' wildcardparameter
@ -873,7 +874,7 @@ fielddeclaration : type fielddeclarator ';'
| |
type variabledeclarators ';' type variabledeclarators ';'
{ {
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("T->Parser->fielddeclaration ...: type " + $1); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("T->Parser->fielddeclaration ...: type " + $1, Section.PARSER);
$2.setType($1); $2.setType($1);
$$ = $2; $$ = $2;
} }
@ -1314,7 +1315,7 @@ referencelongtype : typename parameter
referencetype :classorinterfacetype referencetype :classorinterfacetype
{ {
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("T->Parser->referenctype: " + $1); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("T->Parser->referenctype: " + $1, Section.PARSER);
RefType RT = new RefType(null,$1.getOffset()); RefType RT = new RefType(null,$1.getOffset());
//ausgetauscht PL 05-07-30 //ausgetauscht PL 05-07-30
@ -1385,13 +1386,13 @@ formalparameter : type variabledeclaratorid
//FP.set_DeclId($5); //FP.set_DeclId($5);
$$=FP; $$=FP;
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("P->Polymorphes Methodenargument hinzugefuegt: Name = " + $5.get_Name() + " Typ = " + $1.getName()); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("P->Polymorphes Methodenargument hinzugefuegt: Name = " + $5.get_Name() + " Typ = " + $1.getName(), Section.PARSER);
} }
*/ */
| variabledeclaratorid | variabledeclaratorid
{ {
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("\nFunktionsdeklaration mit typlosen Parametern: " + $1.name); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("\nFunktionsdeklaration mit typlosen Parametern: " + $1.name, Section.PARSER);
FormalParameter FP = new FormalParameter($1); FormalParameter FP = new FormalParameter($1);
@ -1400,7 +1401,7 @@ formalparameter : type variabledeclaratorid
//Type T = TypePlaceholder.fresh(); //auskommentiert von Andreas Stadelmeier //Type T = TypePlaceholder.fresh(); //auskommentiert von Andreas Stadelmeier
// Type T = new TypePlaceholder(""); /* otth: Name wird automatisch berechnet */ // Type T = new TypePlaceholder(""); /* otth: Name wird automatisch berechnet */
// ########################################################### // ###########################################################
//de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("\n--> berechneter Name: " + T.getName()); //de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("\n--> berechneter Name: " + T.getName(), Section.PARSER);
//auskommentiert von Andreas Stadelmeier (a10023) FP.setType( T ); //auskommentiert von Andreas Stadelmeier (a10023) FP.setType( T );
//FP.set_DeclId($1); //FP.set_DeclId($1);
@ -1498,7 +1499,7 @@ integraltype :INT
localvariabledeclaration : type variabledeclarators localvariabledeclaration : type variabledeclarators
{ {
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("P -> Lokale Variable angelegt!"); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("P -> Lokale Variable angelegt!", Section.PARSER);
LocalVarDecl LVD = new LocalVarDecl($1.getOffset(),$1.getVariableLength()); LocalVarDecl LVD = new LocalVarDecl($1.getOffset(),$1.getVariableLength());
LVD.setType($1); LVD.setType($1);
LVD.setDeclidVector($2.getDeclIdVector()); LVD.setDeclidVector($2.getDeclIdVector());
@ -1509,7 +1510,7 @@ localvariabledeclaration : type variabledeclarators
/* ########################################################### */ /* ########################################################### */
|variabledeclarators |variabledeclarators
{ {
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("P -> Lokale Variable angelegt!"); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("P -> Lokale Variable angelegt!", Section.PARSER);
LocalVarDecl LVD = new LocalVarDecl($1.getOffset(),$1.getVariableLength()); LocalVarDecl LVD = new LocalVarDecl($1.getOffset(),$1.getVariableLength());
//auskommentiert von Andreas Stadelmeier (a10023) LVD.setType(TypePlaceholder.fresh()); //auskommentiert von Andreas Stadelmeier (a10023) LVD.setType(TypePlaceholder.fresh());
LVD.setDeclidVector($1.getDeclIdVector()); LVD.setDeclidVector($1.getDeclIdVector());
@ -1648,7 +1649,7 @@ forstatement
assignmentexpression : conditionalexpression assignmentexpression : conditionalexpression
{ {
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("conditionalexpression"); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("conditionalexpression", Section.PARSER);
$$=$1; $$=$1;
} }
| assignment | assignment
@ -1701,7 +1702,7 @@ conditionalexpression :conditionalorexpression
assignment :lefthandside assignmentoperator assignmentexpression assignment :lefthandside assignmentoperator assignmentexpression
{ {
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("\nParser --> Zuweisung1!\n"); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("\nParser --> Zuweisung1!\n", Section.PARSER);
Assign Ass = new Assign($1.getOffset(),$1.getVariableLength()); Assign Ass = new Assign($1.getOffset(),$1.getVariableLength());
LocalOrFieldVar LOFV = new LocalOrFieldVar($1.getOffset(),$1.getVariableLength()); LocalOrFieldVar LOFV = new LocalOrFieldVar($1.getOffset(),$1.getVariableLength());
LOFV.set_UsedId($1); LOFV.set_UsedId($1);
@ -1709,7 +1710,7 @@ assignment :lefthandside assignmentoperator assignmentexpr
//auskommentiert von Andreas Stadelmeier (a10023) Ass.setType(TypePlaceholder.fresh()); //auskommentiert von Andreas Stadelmeier (a10023) Ass.setType(TypePlaceholder.fresh());
if( $2 == null ) if( $2 == null )
{ {
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("\nParser --> Zuweisung1 --> " + $3 + " \n"); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("\nParser --> Zuweisung1 --> " + $3 + " \n", Section.PARSER);
Ass.set_Expr( LOFV,$3 ); Ass.set_Expr( LOFV,$3 );
} }
else else
@ -1718,7 +1719,7 @@ assignment :lefthandside assignmentoperator assignmentexpr
Bin.set_Expr1(LOFV); Bin.set_Expr1(LOFV);
Bin.set_Operator($2); Bin.set_Operator($2);
Bin.set_Expr2($3); Bin.set_Expr2($3);
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("\nParser --> Zuweisung1 --> Binary\n"); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("\nParser --> Zuweisung1 --> Binary\n", Section.PARSER);
//auskommentiert von Andreas Stadelmeier (a10023) Bin.setType(TypePlaceholder.fresh()); //auskommentiert von Andreas Stadelmeier (a10023) Bin.setType(TypePlaceholder.fresh());
Ass.set_Expr( LOFV, Bin ); Ass.set_Expr( LOFV, Bin );
} }
@ -1931,7 +1932,7 @@ postdecrementexpression :postfixexpression DECREMENT
methodinvocation: methodinvocation:
name '(' ')' name '(' ')'
{ {
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("M1"); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("M1", Section.PARSER);
MethodCall MC = new MethodCall($1.getOffset(),$1.getVariableLength()); MethodCall MC = new MethodCall($1.getOffset(),$1.getVariableLength());
UsedId udidmeth = new UsedId($1.getOffset()); UsedId udidmeth = new UsedId($1.getOffset());
udidmeth.set_Name((String)(($1.get_Name()).elementAt($1.get_Name().size()-1))); udidmeth.set_Name((String)(($1.get_Name()).elementAt($1.get_Name().size()-1)));
@ -1961,7 +1962,7 @@ methodinvocation:
} }
| name '('argumentlist')' | name '('argumentlist')'
{ {
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("M2"); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("M2", Section.PARSER);
MethodCall MCarg = new MethodCall($1.getOffset(),$1.getVariableLength()); MethodCall MCarg = new MethodCall($1.getOffset(),$1.getVariableLength());
UsedId udidmeth = new UsedId($1.getOffset()); UsedId udidmeth = new UsedId($1.getOffset());
udidmeth.set_Name((String)(($1.get_Name()).elementAt($1.get_Name().size()-1))); udidmeth.set_Name((String)(($1.get_Name()).elementAt($1.get_Name().size()-1)));
@ -1992,7 +1993,7 @@ methodinvocation:
} }
| primary '.' IDENTIFIER '(' ')' | primary '.' IDENTIFIER '(' ')'
{ {
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("M3"); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("M3", Section.PARSER);
MethodCall MCpr = new MethodCall($1.getOffset(),$1.getVariableLength()); MethodCall MCpr = new MethodCall($1.getOffset(),$1.getVariableLength());
// PL 05-08-21 primary ist kein UsedId // PL 05-08-21 primary ist kein UsedId
@ -2011,7 +2012,7 @@ methodinvocation:
} }
| primary '.' IDENTIFIER '('argumentlist ')' | primary '.' IDENTIFIER '('argumentlist ')'
{ {
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("M4"); de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("M4", Section.PARSER);
MethodCall MCPA = new MethodCall($1.getOffset(),$1.getVariableLength()); MethodCall MCPA = new MethodCall($1.getOffset(),$1.getVariableLength());
// PL 05-08-21 primary ist kein UsedId // PL 05-08-21 primary ist kein UsedId

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

@ -656,7 +656,7 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface, IItemWit
////////////////////////////// //////////////////////////////
// Und los geht's: // Und los geht's:
////////////////////////////// //////////////////////////////
inferencelog.info("Rufe TRStart()..."); inferencelog.info("Rufe TRStart()...", Section.TYPEINFERENCE);
typinferenzLog.debug("Erstellte FiniteClosure: "+supportData, Section.TYPEINFERENCE); typinferenzLog.debug("Erstellte FiniteClosure: "+supportData, Section.TYPEINFERENCE);
////////////////////////////// //////////////////////////////

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

@ -279,7 +279,7 @@ static String string_rec(String st,Vector v)
// ******************************************************************************************** // ********************************************************************************************
// //
// ino.end // ino.end
/*
// ino.method.istParameterOK.23200.definition // ino.method.istParameterOK.23200.definition
public void istParameterOK( Vector Parameter, Vector<Class> KlassenVektor ) public void istParameterOK( Vector Parameter, Vector<Class> KlassenVektor )
// ino.end // ino.end
@ -305,7 +305,7 @@ public void istParameterOK( Vector Parameter, Vector<Class> KlassenVektor )
{ {
if( ((RefType)TempParameter).get_ParaList().size() != KlassenVektor.elementAt(k).get_ParaList().size() ) if( ((RefType)TempParameter).get_ParaList().size() != KlassenVektor.elementAt(k).get_ParaList().size() )
{ {
parserlog.error( "SEMANTIK-CHECK-FEHLER: Parameteranzahl von\n" + TempParameter.getName() + " stimmt mit der Klassendefinition\n" + KlassenVektor.elementAt(k).getName() + " nicht <20>berein." ); parserlog.error( "SEMANTIK-CHECK-FEHLER: Parameteranzahl von\n" + TempParameter.getName() + " stimmt mit der Klassendefinition\n" + KlassenVektor.elementAt(k).getName() + " nicht <20>berein.", Section.OLD );
System.exit( 1 ); System.exit( 1 );
} }
else else
@ -346,7 +346,7 @@ public void istParameterOK( Vector Parameter, Vector<Class> KlassenVektor )
} // end otth; end if: t = RefType } // end otth; end if: t = RefType
} }
// ino.end // ino.end
*/
// ino.method.toString.23203.defdescription type=javadoc // ino.method.toString.23203.defdescription type=javadoc
/** /**

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

@ -49,11 +49,6 @@ public class Constructor extends Method {
return this.methode.getGenericMethodParameters(); return this.methode.getGenericMethodParameters();
} }
*/ */
@Override
public void sc_init_parameterlist(boolean ext) {
this.methode.sc_init_parameterlist(ext);
}
@Override @Override
public JavaClassName getTypeName() { public JavaClassName getTypeName() {

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

@ -209,7 +209,9 @@ public class FormalParameter extends SyntaxTreeNode implements Typeable, TypeIns
@Override @Override
public Vector<SyntaxTreeNode> getChildren() { public Vector<SyntaxTreeNode> getChildren() {
return new Vector<SyntaxTreeNode>(); Vector<SyntaxTreeNode> ret = new Vector<SyntaxTreeNode>();
if(type != null)ret.add(this.type);
return ret;
} }

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

@ -116,6 +116,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
} }
// ino.end // ino.end
*/ */
/*
// ino.method.sc_init_parameterlist.23530.definition // ino.method.sc_init_parameterlist.23530.definition
public void sc_init_parameterlist(boolean ext) public void sc_init_parameterlist(boolean ext)
// ino.end // ino.end
@ -157,7 +158,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
} }
} }
// ino.end // ino.end
*/
// ino.method.getTypeName.23533.defdescription type=line // ino.method.getTypeName.23533.defdescription type=line
// Eine der beiden Funktionen ist ueberflssig. Wer sich daran strt kann die // Eine der beiden Funktionen ist ueberflssig. Wer sich daran strt kann die
// get_ReturnType() auf eigene Gefahr lschen. // get_ReturnType() auf eigene Gefahr lschen.

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

@ -327,7 +327,7 @@ public class SourceFile
for( int i = 0; i < KlassenVektor.size(); i++ ) for( int i = 0; i < KlassenVektor.size(); i++ )
{ {
Class tempKlasse = KlassenVektor.elementAt(i); Class tempKlasse = KlassenVektor.elementAt(i);
inferencelog.debug("Verarbeite "+tempKlasse.getName()); inferencelog.debug("Verarbeite "+tempKlasse.getName(), Section.TYPEINFERENCE);
//TODO: SuperKlasse erstellen, dies sollte am besten beim Konstruktoraufruf von Class geschehen. Diese kann dann mit getSuperClass abgefragt werden. //TODO: SuperKlasse erstellen, dies sollte am besten beim Konstruktoraufruf von Class geschehen. Diese kann dann mit getSuperClass abgefragt werden.
if( tempKlasse.superclassid != null ) { // Klasse hat Superklasse if( tempKlasse.superclassid != null ) { // Klasse hat Superklasse
Pair P=createPairFromClassAndSuperclass(tempKlasse,tempKlasse.getSuperClass(),tempKlasse.get_ParaList(),tempKlasse.superclassid.get_ParaList(), globalAssumptions); Pair P=createPairFromClassAndSuperclass(tempKlasse,tempKlasse.getSuperClass(),tempKlasse.get_ParaList(),tempKlasse.superclassid.get_ParaList(), globalAssumptions);
@ -398,7 +398,7 @@ public class SourceFile
Vector<Type> vPara = ((RefType)(PTypKonst.TA2)).get_ParaList(); Vector<Type> vPara = ((RefType)(PTypKonst.TA2)).get_ParaList();
RefType Subst = null; // Substitution RefType Subst = null; // Substitution
int nSubstStelle = 0; int nSubstStelle = 0;
inferencelog.debug("nSubstStelleStart" + nSubstStelle + " " + n); inferencelog.debug("nSubstStelleStart" + nSubstStelle + " " + n, Section.FINITECLOSURE);
// Parameter durchlaufen und nach Typkonstruktor suchen // Parameter durchlaufen und nach Typkonstruktor suchen
// #JB# 17.05.2005 // #JB# 17.05.2005
@ -407,13 +407,13 @@ public class SourceFile
// ########################################################### // ###########################################################
for( ; nSubstStelle < vPara.size(); nSubstStelle++ ) for( ; nSubstStelle < vPara.size(); nSubstStelle++ )
{ {
inferencelog.debug("nSubstStelle" + nSubstStelle); inferencelog.debug("nSubstStelle" + nSubstStelle, Section.FINITECLOSURE);
if( vPara.elementAt(nSubstStelle) instanceof RefType && ((RefType)vPara.elementAt(nSubstStelle)).get_ParaList() != null ) if( vPara.elementAt(nSubstStelle) instanceof RefType && ((RefType)vPara.elementAt(nSubstStelle)).get_ParaList() != null )
{ {
// Typkonstruktor gefunden -> wird nun als Substitution verwendet // Typkonstruktor gefunden -> wird nun als Substitution verwendet
Subst = new RefType( (RefType)vPara.elementAt(nSubstStelle) ,-1); Subst = new RefType( (RefType)vPara.elementAt(nSubstStelle) ,-1);
inferencelog.debug( "Ausgangstyp:" + ((RefType)PTypKonst.TA2).getName() ); inferencelog.debug( "Ausgangstyp:" + ((RefType)PTypKonst.TA2).getName() , Section.FINITECLOSURE);
inferencelog.debug( "RefType = " + ((RefType)vPara.elementAt(nSubstStelle)).getName() ); inferencelog.debug( "RefType = " + ((RefType)vPara.elementAt(nSubstStelle)).getName() , Section.FINITECLOSURE);
break; // Einschraenkung - nur fuer ein RefType wird eine Substitution gesucht break; // Einschraenkung - nur fuer ein RefType wird eine Substitution gesucht
} }
} }
@ -431,8 +431,8 @@ public class SourceFile
Pair PSuchen = vFC.elementAt(t); Pair PSuchen = vFC.elementAt(t);
if( ((RefType)(PTypKonst.TA2)).getTypeName().equals( ((RefType)PSuchen.TA1).getTypeName() ) ) if( ((RefType)(PTypKonst.TA2)).getTypeName().equals( ((RefType)PSuchen.TA1).getTypeName() ) )
{ {
inferencelog.debug(" gefundener Typ links: " + ((RefType)(PSuchen.TA1)).getName() ); inferencelog.debug(" gefundener Typ links: " + ((RefType)(PSuchen.TA1)).getName(), Section.FINITECLOSURE );
inferencelog.debug(" gefundener Typ rechts: " + ((RefType)(PSuchen.TA2)).getName() ); inferencelog.debug(" gefundener Typ rechts: " + ((RefType)(PSuchen.TA2)).getName() , Section.FINITECLOSURE);
// Paar gefunden, das als linken Typ den gleichen Typen enth<EFBFBD>lt, der als Parameter einen Typkonstruktor hat // Paar gefunden, das als linken Typ den gleichen Typen enth<EFBFBD>lt, der als Parameter einen Typkonstruktor hat
// Substitution // Substitution
//Pair P = new Pair( PSuchen.getTA1Copy( ), PSuchen.getTA2Copy( ) ); //Pair P = new Pair( PSuchen.getTA1Copy( ), PSuchen.getTA2Copy( ) );
@ -470,12 +470,12 @@ public class SourceFile
//TV = new TypePlaceholder( ((RefType)PSuchen.TA1).getParaN(u) ); //TV = new TypePlaceholder( ((RefType)PSuchen.TA1).getParaN(u) );
//System.out.println("TV_Name: " + u + TV.Type2String()); //System.out.println("TV_Name: " + u + TV.Type2String());
// ########################################################### // ###########################################################
inferencelog.debug("Typterm_Name: " + vPara.elementAt(u)); inferencelog.debug("Typterm_Name: " + vPara.elementAt(u), Section.FINITECLOSURE);
inferencelog.debug("Typterm_Name: " + ((Type)vPara.elementAt(u)).Type2String()); inferencelog.debug("Typterm_Name: " + ((Type)vPara.elementAt(u)).Type2String(), Section.FINITECLOSURE);
hts.put(new JavaClassName(((RefType)PSuchen.TA1).getParaN(u)), vPara.elementAt(u)); hts.put(new JavaClassName(((RefType)PSuchen.TA1).getParaN(u)), vPara.elementAt(u));
} }
catch( Exception E ) { catch( Exception E ) {
inferencelog.error(E.getMessage()); inferencelog.error(E.getMessage(), Section.FINITECLOSURE);
//FIXME Throw Exception or Error instead of exiting! //FIXME Throw Exception or Error instead of exiting!
System.exit(0); System.exit(0);
} }

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

@ -8,7 +8,7 @@ import java.util.Iterator;
import java.util.Vector; import java.util.Vector;
import de.dhbwstuttgart.logger.Logger; import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.bytecode.ClassFile; import de.dhbwstuttgart.bytecode.ClassFile;
import de.dhbwstuttgart.bytecode.CodeAttribute; import de.dhbwstuttgart.bytecode.CodeAttribute;
import de.dhbwstuttgart.myexception.CTypeReconstructionException; import de.dhbwstuttgart.myexception.CTypeReconstructionException;
@ -171,7 +171,7 @@ public class Block extends Statement
if(statements.size()==0)this.setType(new Void(this,0)); if(statements.size()==0)this.setType(new Void(this,0));
/* this.setTypeVariable(TypePlaceholder.fresh(this)); */ /* this.setTypeVariable(TypePlaceholder.fresh(this)); */
for(Statement stmt : statements){ for(Statement stmt : statements){
typinferenceLog.debug("Prozessing statement: "+stmt); typinferenceLog.debug("Prozessing statement: "+stmt, Section.TYPEINFERENCE);
ret.add(stmt.TYPEStmt(assumptions)); ret.add(stmt.TYPEStmt(assumptions));
/* if((stmt instanceof Return)){ /* if((stmt instanceof Return)){
ret.add(new Constraint(stmt.getTypeVariable(), this.getTypeVariable()));//TODO: Dies nochmal prüfen. ret.add(new Constraint(stmt.getTypeVariable(), this.getTypeVariable()));//TODO: Dies nochmal prüfen.
@ -180,11 +180,11 @@ public class Block extends Statement
} }
if(statements.size()>0){ if(statements.size()>0){
Statement stmt = statements.elementAt(statements.size()-1); Statement stmt = statements.elementAt(statements.size()-1);
typinferenceLog.debug("Prozessing statement: "+stmt); typinferenceLog.debug("Prozessing statement: "+stmt, Section.TYPEINFERENCE);
this.setType(stmt.getType()); this.setType(stmt.getType());
for(int i= statements.size()-2; i >= 0; i--) { for(int i= statements.size()-2; i >= 0; i--) {
stmt = statements.elementAt(i); stmt = statements.elementAt(i);
typinferenceLog.debug("Prozessing statement: "+stmt); typinferenceLog.debug("Prozessing statement: "+stmt, Section.TYPEINFERENCE);
if (!(stmt.getReturnType() instanceof Void)) if (!(stmt.getReturnType() instanceof Void))
if (this.getReturnType() instanceof Void) { if (this.getReturnType() instanceof Void) {
//this.setTypeVariable(stmt.getTypeVariable()); //this.setTypeVariable(stmt.getTypeVariable());

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

@ -54,7 +54,7 @@ public class BoolLiteral extends Literal
// ino.end // ino.end
/*
// ino.method.sc_check.25102.definition // ino.method.sc_check.25102.definition
public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach,Hashtable<String, Hashtable> parabh) public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach,Hashtable<String, Hashtable> parabh)
// ino.end // ino.end
@ -66,7 +66,7 @@ public class BoolLiteral extends Literal
} }
} }
// ino.end // ino.end
*/
// ino.method.set_Bool.25105.definition // ino.method.set_Bool.25105.definition

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

@ -53,7 +53,7 @@ public class CharLiteral extends Literal
// ino.end // ino.end
/*
// ino.method.sc_check.25179.definition // ino.method.sc_check.25179.definition
public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh) public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh)
// ino.end // ino.end
@ -63,7 +63,7 @@ public class CharLiteral extends Literal
parserlog.debug(" ---CharLiteral---"); parserlog.debug(" ---CharLiteral---");
} }
// ino.end // ino.end
*/
// ino.method.set_Char.25182.definition // ino.method.set_Char.25182.definition
public void set_Char( char c) public void set_Char( char c)
// ino.end // ino.end

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

@ -73,6 +73,7 @@ public class DoubleLiteral extends Literal
} }
// ino.end // ino.end
/*
// ino.method.sc_check.25466.definition // ino.method.sc_check.25466.definition
public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh) public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh)
// ino.end // ino.end
@ -81,6 +82,7 @@ public class DoubleLiteral extends Literal
parserlog.debug("SC -> Semantik-Check f<>r DoubleLiteral wurde aufgerufen --> nichts zu tun!"); parserlog.debug("SC -> Semantik-Check f<>r DoubleLiteral wurde aufgerufen --> nichts zu tun!");
} }
// ino.end // ino.end
*/
// ino.method.get_Name.25469.definition // ino.method.get_Name.25469.definition
public String get_Name() public String get_Name()

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

@ -42,6 +42,7 @@ public class EmptyStmt extends Statement
// ino.attribute.parserlog.25210.declaration // ino.attribute.parserlog.25210.declaration
protected static Logger parserlog = Logger.getLogger("parser"); protected static Logger parserlog = Logger.getLogger("parser");
// ino.end // ino.end
/*
// ino.method.sc_check.25213.definition // ino.method.sc_check.25213.definition
public void sc_check(Vector<Class> classlist, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh) public void sc_check(Vector<Class> classlist, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh)
// ino.end // ino.end
@ -52,7 +53,8 @@ public class EmptyStmt extends Statement
} }
} }
// ino.end // ino.end
*/
// ino.method.codegen.25216.definition // ino.method.codegen.25216.definition
public void codegen(ClassFile classfile, CodeAttribute code, Vector paralist) public void codegen(ClassFile classfile, CodeAttribute code, Vector paralist)
throws JVMCodeException throws JVMCodeException

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

@ -68,6 +68,7 @@ public class FloatLiteral extends Literal
} }
// ino.end // ino.end
/*
// ino.method.sc_check.25466.definition // ino.method.sc_check.25466.definition
public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh) public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh)
// ino.end // ino.end
@ -76,7 +77,8 @@ public class FloatLiteral extends Literal
parserlog.debug("SC -> Semantik-Check f<>r FloatLiteral wurde aufgerufen --> nichts zu tun!"); parserlog.debug("SC -> Semantik-Check f<>r FloatLiteral wurde aufgerufen --> nichts zu tun!");
} }
// ino.end // ino.end
*/
// ino.method.get_Name.25469.definition // ino.method.get_Name.25469.definition
public String get_Name() public String get_Name()
// ino.end // ino.end

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

@ -111,6 +111,7 @@ public class InstVar extends Expr
if(this.getType()==null)this.set_Type(TypePlaceholder.fresh(this)); if(this.getType()==null)this.set_Type(TypePlaceholder.fresh(this));
} }
/*
// ino.method.sc_check.25417.definition // ino.method.sc_check.25417.definition
public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh) public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh)
// ino.end // ino.end
@ -142,7 +143,7 @@ public class InstVar extends Expr
} }
} }
// ino.end // ino.end
*/
// ino.method.get_Name.25420.definition // ino.method.get_Name.25420.definition
public String get_Name() public String get_Name()
// ino.end // ino.end
@ -188,7 +189,9 @@ public class InstVar extends Expr
// ino.end // ino.end
// ino.method.toString.25441.body // ino.method.toString.25441.body
{ {
return super.type.toString() + " " + usedid.toString(); String superType = "";
if(super.type != null)superType += super.type.toString();
return superType + " " + usedid.toString();
} }
// ino.end // ino.end

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

@ -71,6 +71,7 @@ public class IntLiteral extends Literal
} }
// ino.end // ino.end
/*
// ino.method.sc_check.25466.definition // ino.method.sc_check.25466.definition
public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh) public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh)
// ino.end // ino.end
@ -79,6 +80,7 @@ public class IntLiteral extends Literal
parserlog.debug("SC -> Semantik-Check f<>r IntLiteral wurde aufgerufen --> nichts zu tun!"); parserlog.debug("SC -> Semantik-Check f<>r IntLiteral wurde aufgerufen --> nichts zu tun!");
} }
// ino.end // ino.end
*/
// ino.method.get_Name.25469.definition // ino.method.get_Name.25469.definition
public String get_Name() public String get_Name()

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

@ -151,6 +151,7 @@ public class LocalVarDecl extends Statement implements TypeInsertable
} }
// ino.end // ino.end
/*
// ino.method.check_anz.25590.definition // ino.method.check_anz.25590.definition
public void check_anz(Type type, Vector paralist, Vector<Class> classlist) public void check_anz(Type type, Vector paralist, Vector<Class> classlist)
throws SCStatementException throws SCStatementException
@ -243,7 +244,7 @@ public class LocalVarDecl extends Statement implements TypeInsertable
} }
// ino.end // ino.end
*/

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

@ -72,6 +72,7 @@ public class LongLiteral extends Literal
} }
// ino.end // ino.end
/*
// ino.method.sc_check.25466.definition // ino.method.sc_check.25466.definition
public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh) public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh)
// ino.end // ino.end
@ -80,6 +81,7 @@ public class LongLiteral extends Literal
parserlog.debug("SC -> Semantik-Check f<>r LongLiteral wurde aufgerufen --> nichts zu tun!"); parserlog.debug("SC -> Semantik-Check f<>r LongLiteral wurde aufgerufen --> nichts zu tun!");
} }
// ino.end // ino.end
*/
// ino.method.get_Name.25469.definition // ino.method.get_Name.25469.definition
public String get_Name() public String get_Name()

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

@ -88,6 +88,7 @@ public class NewArray extends Expr
} }
// ino.end // ino.end
/*
// ino.method.sc_check.25812.definition // ino.method.sc_check.25812.definition
public void sc_check(Vector<Class> classname, Hashtable bh, Hashtable<String, String> ch,boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh) public void sc_check(Vector<Class> classname, Hashtable bh, Hashtable<String, String> ch,boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh)
// ino.end // ino.end
@ -97,6 +98,7 @@ public class NewArray extends Expr
parserlog.debug(" ---NewArray---"); parserlog.debug(" ---NewArray---");
} }
// ino.end // ino.end
*/
// ino.method.get_codegen_Array_Type.25815.definition // ino.method.get_codegen_Array_Type.25815.definition
public int get_codegen_Array_Type() public int get_codegen_Array_Type()

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

@ -55,6 +55,7 @@ public class Null extends Literal
} }
// ino.end // ino.end
/*
// ino.method.sc_check.25932.definition // ino.method.sc_check.25932.definition
public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh) public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh)
// ino.end // ino.end
@ -64,6 +65,7 @@ public class Null extends Literal
parserlog.debug(" ---Null---"); parserlog.debug(" ---Null---");
} }
// ino.end // ino.end
*/
// ino.method.codegen.25935.definition // ino.method.codegen.25935.definition
public void codegen(ClassFile classfile, CodeAttribute code, Vector paralist) public void codegen(ClassFile classfile, CodeAttribute code, Vector paralist)

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

@ -76,6 +76,7 @@ public class PositivExpr extends UnaryExpr
} }
// ino.end // ino.end
/*
// ino.method.sc_check.25972.definition // ino.method.sc_check.25972.definition
public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh) public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh)
// ino.end // ino.end
@ -86,6 +87,7 @@ public class PositivExpr extends UnaryExpr
//Wartet noch auf Implementierung //Wartet noch auf Implementierung
} }
// ino.end // ino.end
*/
// ino.method.codegen.25975.definition // ino.method.codegen.25975.definition
public void codegen(ClassFile classfile, CodeAttribute code, Vector paralist) public void codegen(ClassFile classfile, CodeAttribute code, Vector paralist)

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

@ -55,6 +55,7 @@ public class StringLiteral extends Literal
} }
// ino.end // ino.end
/*
// ino.method.sc_check.26240.definition // ino.method.sc_check.26240.definition
public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh) public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh)
// ino.end // ino.end
@ -64,6 +65,7 @@ public class StringLiteral extends Literal
parserlog.debug(" ---StringLiteral---"); parserlog.debug(" ---StringLiteral---");
} }
// ino.end // ino.end
*/
// ino.method.set_String.26243.definition // ino.method.set_String.26243.definition
public void set_String( String s) public void set_String( String s)

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

@ -77,7 +77,7 @@ public class This extends Expr
} }
// ino.end // ino.end
/*
// ino.method.sc_check.26280.definition // ino.method.sc_check.26280.definition
public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh) public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh)
throws SCStatementException throws SCStatementException
@ -88,6 +88,7 @@ public class This extends Expr
parserlog.debug(" ---This---"); parserlog.debug(" ---This---");
} }
// ino.end // ino.end
*/
// ino.method.codegen.26283.definition // ino.method.codegen.26283.definition
public void codegen(ClassFile classfile, CodeAttribute code, Vector paralist) public void codegen(ClassFile classfile, CodeAttribute code, Vector paralist)

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

@ -3,8 +3,10 @@ package de.dhbwstuttgart.syntaxtree.type;
// ino.end // ino.end
// ino.module.ParaList.8674.import // ino.module.ParaList.8674.import
import java.util.Vector; import java.util.Vector;
import de.dhbwstuttgart.logger.Logger; import de.dhbwstuttgart.logger.Logger;
// ino.end // ino.end
import de.dhbwstuttgart.logger.Section;
@ -32,7 +34,7 @@ public class ParaList extends Vector<Type>
// ino.end // ino.end
// ino.method.ParaList.26603.body // ino.method.ParaList.26603.body
{ {
parserlog.debug( "ParaList: " + t ); parserlog.debug( "ParaList: " + t, Section.PARSER );
this.addElement(t); this.addElement(t);
} }
// ino.end // ino.end
@ -52,7 +54,6 @@ public class ParaList extends Vector<Type>
// ino.method.add_ParaList.26609.body // ino.method.add_ParaList.26609.body
{ {
this.addElement(obj); this.addElement(obj);
parserlog.debug("ParaList: " + obj);
} }
// ino.end // ino.end

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

@ -8,8 +8,9 @@ import java.util.Hashtable;
import java.util.Iterator; import java.util.Iterator;
import java.util.Vector; import java.util.Vector;
import de.dhbwstuttgart.logger.Logger; import org.antlr.v4.runtime.misc.NotNull;
import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.bytecode.JVMCode; import de.dhbwstuttgart.bytecode.JVMCode;
import de.dhbwstuttgart.core.IItemWithOffset; import de.dhbwstuttgart.core.IItemWithOffset;
import de.dhbwstuttgart.myexception.SCException; import de.dhbwstuttgart.myexception.SCException;
@ -346,6 +347,7 @@ public class RefType extends Type implements IMatchable
// ino.end // ino.end
public Vector<Type> getParaList(){ public Vector<Type> getParaList(){
if(this.parameter==null)return new Vector<>();
return this.parameter; return this.parameter;
} }
@ -806,6 +808,13 @@ public class RefType extends Type implements IMatchable
return t; return t;
} }
@Override
public Vector<SyntaxTreeNode> getChildren() {
Vector<SyntaxTreeNode> ret = super.getChildren();
ret.addAll(this.getParaList());
return ret;
}
@Override @Override
public Type checkTYPE(TypeAssumptions ass, SyntaxTreeNode method) { public Type checkTYPE(TypeAssumptions ass, SyntaxTreeNode method) {
Type t = ass.checkType(this, parent); Type t = ass.checkType(this, parent);

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

@ -49,6 +49,7 @@ public abstract class Type extends SyntaxTreeNode implements IItemWithOffset
// ino.end // ino.end
// ino.method.Type.26732.body // ino.method.Type.26732.body
{ {
//if(parent == null)throw new NullPointerException();
this.parent = parent; this.parent = parent;
this.offset=offset; this.offset=offset;
} }
@ -193,7 +194,7 @@ public abstract class Type extends SyntaxTreeNode implements IItemWithOffset
/** /**
* <br>Author: J<EFBFBD>rg B<EFBFBD>uerle * <br>Author: J<EFBFBD>rg B<EFBFBD>uerle
* @return * @return
*/
// ino.end // ino.end
// ino.method.clone.26768.definition // ino.method.clone.26768.definition
public Type clone() public Type clone()
@ -203,6 +204,9 @@ public abstract class Type extends SyntaxTreeNode implements IItemWithOffset
return new RefType(this.getName().toString(), this.getParent(),getOffset()); return new RefType(this.getName().toString(), this.getParent(),getOffset());
} }
// ino.end // ino.end
*/
public abstract Type clone();
// ino.method.toString.26771.defdescription type=javadoc // ino.method.toString.26771.defdescription type=javadoc
/** /**
@ -219,6 +223,7 @@ public abstract class Type extends SyntaxTreeNode implements IItemWithOffset
} }
// ino.end // ino.end
/*
// ino.method.removeClassParameters.26774.definition // ino.method.removeClassParameters.26774.definition
public Type removeClassParameters() public Type removeClassParameters()
// ino.end // ino.end
@ -233,7 +238,8 @@ public abstract class Type extends SyntaxTreeNode implements IItemWithOffset
} }
} }
// ino.end // ino.end
*/
// ino.method.getSimpleName.26777.defdescription type=javadoc // ino.method.getSimpleName.26777.defdescription type=javadoc
/** /**
* HOTI * HOTI

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

@ -55,6 +55,7 @@ public class TypePlaceholder extends Type
// ino.method.TypePlaceholder.26794.body // ino.method.TypePlaceholder.26794.body
{ {
super(parent, -1); super(parent, -1);
if(typeName == null)throw new NullPointerException();
this.name = new JavaClassName(typeName); this.name = new JavaClassName(typeName);
if(parent != null)log.debug("Erstelle TPH "+typeName+" für SyntaxTreeNode: "+parent, Section.TYPEINFERENCE); if(parent != null)log.debug("Erstelle TPH "+typeName+" für SyntaxTreeNode: "+parent, Section.TYPEINFERENCE);
} }

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

@ -40,7 +40,7 @@ public class ConstraintsSet implements Iterable<OderConstraint>{
*/ */
return ret; return ret;
} }
@Override @Override
public String toString(){ public String toString(){
String ret =""; String ret ="";

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

@ -3,8 +3,11 @@ package de.dhbwstuttgart.typeinference.assumptions;
import java.util.Iterator; import java.util.Iterator;
import java.util.Vector; import java.util.Vector;
import org.antlr.v4.tool.ast.SetAST;
import de.dhbwstuttgart.core.IItemWithOffset; import de.dhbwstuttgart.core.IItemWithOffset;
import de.dhbwstuttgart.logger.Logger; import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.parser.JavaClassName; import de.dhbwstuttgart.parser.JavaClassName;
import de.dhbwstuttgart.syntaxtree.Class; import de.dhbwstuttgart.syntaxtree.Class;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
@ -363,7 +366,7 @@ public class TypeAssumptions {
*/ */
public ConstructorAssumption getConstructorAssumption(String name, int size) { public ConstructorAssumption getConstructorAssumption(String name, int size) {
for(ConstructorAssumption ca : this.constructorAssumptions){ for(ConstructorAssumption ca : this.constructorAssumptions){
log.debug("Durchsuche Assumptions: "+ca.getIdentifier().toString() +" -Anzahl Parameter: "+ ca.getParaCount()); log.debug("Durchsuche Assumptions: "+ca.getIdentifier().toString() +" -Anzahl Parameter: "+ ca.getParaCount(), Section.TYPEINFERENCE);
if(ca.getParaCount()==size && ca.getIdentifier().equals(name))return ca; if(ca.getParaCount()==size && ca.getIdentifier().equals(name))return ca;
} }
return null; return null;

4
src/de/dhbwstuttgart/typeinference/typedeployment/TypeInsertSet.java
View File

@ -6,7 +6,7 @@ import java.util.Iterator;
import java.util.Vector; import java.util.Vector;
import de.dhbwstuttgart.logger.Logger; import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.core.IItemWithOffset; import de.dhbwstuttgart.core.IItemWithOffset;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar; import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar;
@ -81,7 +81,7 @@ public class TypeInsertSet {
} }
} }
GenericTypeInsertPoint gip = new GenericTypeInsertPoint(tip.getGenericTypeVarInsertNode(), gPatch, resultSet); GenericTypeInsertPoint gip = new GenericTypeInsertPoint(tip.getGenericTypeVarInsertNode(), gPatch, resultSet);
typinferenzLog.debug("Erstellter GenericTypeInsertPoint: "+gip); typinferenzLog.debug("Erstellter GenericTypeInsertPoint: "+gip, Section.TYPEINFERENCE);
tpj.add(tip); tpj.add(tip);
tpj.add(gip); tpj.add(gip);
} }

9
src/de/dhbwstuttgart/typeinference/unify/Unify.java
View File

@ -7,7 +7,10 @@ import java.util.Enumeration;
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 de.dhbwstuttgart.logger.Logger; import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.logger.SectionLogger;
import de.dhbwstuttgart.core.MyCompiler; import de.dhbwstuttgart.core.MyCompiler;
import de.dhbwstuttgart.myexception.CTypeReconstructionException; import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.myexception.MatchException; import de.dhbwstuttgart.myexception.MatchException;
@ -46,7 +49,7 @@ public class Unify
{ {
// ino.attribute.inferencelog.28052.declaration // ino.attribute.inferencelog.28052.declaration
protected static Logger inferencelog = Logger.getLogger("inference"); protected static SectionLogger inferencelog = Logger.getSectionLogger("inference", Section.UNIFY);
// ino.end // ino.end
/** /**
@ -1068,10 +1071,6 @@ throws MatchException
for(int i=0; i < FCtype.get_ParaList().size(); i++) { for(int i=0; i < FCtype.get_ParaList().size(); i++) {
if (FCtype.get_ParaList().elementAt(i) instanceof GenericTypeVar) { if (FCtype.get_ParaList().elementAt(i) instanceof GenericTypeVar) {
inferencelog.debug("PUT"); inferencelog.debug("PUT");
//TODO Auf Korrektheit prüfen:
if(tomatch.getParaList().size() != FCtype.getParaList().size()){
throw new MatchException("Different Parameter Sizes!");
}//Angefügt von Andreas Stadelmeier (ENDE)
ht.put(((GenericTypeVar)FCtype.get_ParaList().elementAt(i)).getName(), ht.put(((GenericTypeVar)FCtype.get_ParaList().elementAt(i)).getName(),
tomatch.get_ParaList().elementAt(i)); tomatch.get_ParaList().elementAt(i));
} }

5
test/plugindevelopment/TypeInsertTester.java
View File

@ -11,7 +11,8 @@ import java.nio.file.Paths;
import java.util.Vector; import java.util.Vector;
import de.dhbwstuttgart.logger.Logger; import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.LoggerConfiguration;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.core.MyCompiler; import de.dhbwstuttgart.core.MyCompiler;
import de.dhbwstuttgart.core.MyCompilerAPI; import de.dhbwstuttgart.core.MyCompilerAPI;
import de.dhbwstuttgart.parser.JavaParser.yyException; import de.dhbwstuttgart.parser.JavaParser.yyException;
@ -26,7 +27,7 @@ public class TypeInsertTester{
private static Logger inferencelog = Logger.getLogger(TypeInsertTester.class.getName()); private static Logger inferencelog = Logger.getLogger(TypeInsertTester.class.getName());
static{ static{
{ {
Logger.setStandardOutput(System.out); Logger.setStandardConfiguration(new LoggerConfiguration().setOutput(Section.TYPEINFERENCE, System.out));
/* /*
// Ausgabeoptionen fuer die Logger // Ausgabeoptionen fuer die Logger
ConsoleAppender logAppender = new ConsoleAppender(new SimpleLayout()); ConsoleAppender logAppender = new ConsoleAppender(new SimpleLayout());

3
test/plugindevelopment/TypeInsertTests/GenericTypeVarTest.java
View File

@ -9,13 +9,14 @@ public class GenericTypeVarTest {
private static final String TEST_FILE = "GenericTypeVarTest.jav"; private static final String TEST_FILE = "GenericTypeVarTest.jav";
private static final String TEST_FILE2 = "GenericTypeVarTest2.jav"; private static final String TEST_FILE2 = "GenericTypeVarTest2.jav";
/*
@Test @Test
public void run(){ public void run(){
Vector<String> mustContain = new Vector<String>(); Vector<String> mustContain = new Vector<String>();
mustContain.add("String methode"); mustContain.add("String methode");
MultipleTypesInsertTester.test(this.TEST_FILE, mustContain); MultipleTypesInsertTester.test(this.TEST_FILE, mustContain);
} }
*/
@Test @Test
public void run2(){ public void run2(){
Vector<String> mustContain = new Vector<String>(); Vector<String> mustContain = new Vector<String>();

2
test/plugindevelopment/TypeInsertTests/LambdaTest24.java
View File

@ -10,7 +10,7 @@ public class LambdaTest24 {
@Test @Test
public void run(){ public void run(){
Vector<String> mustContain = new Vector<String>(); Vector<String> mustContain = new Vector<String>();
mustContain.add("Fun2"); mustContain.add("Fun1");
MultipleTypesInsertTester.testSingleInsert(this.TEST_FILE, mustContain); MultipleTypesInsertTester.testSingleInsert(this.TEST_FILE, mustContain);
} }
} }

2
test/plugindevelopment/TypeInsertTests/LambdaTest4.java
View File

@ -11,7 +11,7 @@ public class LambdaTest4 {
@Test @Test
public void run(){ public void run(){
Vector<String> mustContain = new Vector<String>(); Vector<String> mustContain = new Vector<String>();
mustContain.add("String var"); //mustContain.add("String var");
MultipleTypesInsertTester.test(this.TEST_FILE, mustContain); MultipleTypesInsertTester.test(this.TEST_FILE, mustContain);
} }

9
test/plugindevelopment/TypeInsertTests/MultipleTypesInsertTester.java
View File

@ -6,6 +6,9 @@ import java.util.Vector;
import de.dhbwstuttgart.core.MyCompiler; import de.dhbwstuttgart.core.MyCompiler;
import de.dhbwstuttgart.core.MyCompilerAPI; import de.dhbwstuttgart.core.MyCompilerAPI;
import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.LoggerConfiguration;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.parser.JavaParser.yyException; import de.dhbwstuttgart.parser.JavaParser.yyException;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet; import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertPoint; import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertPoint;
@ -17,6 +20,11 @@ public class MultipleTypesInsertTester extends TypeInsertTester{
public final static String rootDirectory = System.getProperty("user.dir")+"/test/plugindevelopment/TypeInsertTests/"; public final static String rootDirectory = System.getProperty("user.dir")+"/test/plugindevelopment/TypeInsertTests/";
public MultipleTypesInsertTester(){
//Output von TYPEINFERENCE auf die Console setzen:
Logger.setStandardConfiguration(new LoggerConfiguration().setOutput(Section.TYPEINFERENCE, System.out));
}
public static void test(String sourceFileToInfere, Vector<String> mustContain){ public static void test(String sourceFileToInfere, Vector<String> mustContain){
String gesamterSrc = ""; String gesamterSrc = "";
String inferedSource = ""; String inferedSource = "";
@ -24,6 +32,7 @@ public class MultipleTypesInsertTester extends TypeInsertTester{
try { try {
compiler.parse(new File(rootDirectory + sourceFileToInfere)); compiler.parse(new File(rootDirectory + sourceFileToInfere));
Vector<TypeinferenceResultSet> results = compiler.typeReconstruction(); Vector<TypeinferenceResultSet> results = compiler.typeReconstruction();
System.out.println("Typinferenz ausgeführt!");
//TestCase.assertTrue("Es darf nicht mehr als eine Lösungsmöglichkeit geben und nicht "+results.size(), results.size()==1); //TestCase.assertTrue("Es darf nicht mehr als eine Lösungsmöglichkeit geben und nicht "+results.size(), results.size()==1);
for(TypeinferenceResultSet result : results){ for(TypeinferenceResultSet result : results){
TypeInsertSet point = result.getTypeInsertionPoints(); TypeInsertSet point = result.getTypeInsertionPoints();