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/
/mycompiler/
/parser/
/plugindevelopment/
/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 de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.LoggerConfiguration;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
public class ConsoleInterface {
@ -20,7 +20,7 @@ public class ConsoleInterface {
for(String file : args){
filenames.add(file);
}
Logger.setStandardOutput(null); // sämtliches Logging unterdrücken
Logger.setStandardConfiguration(new LoggerConfiguration()); // sämtliches Logging unterdrücken
run(filenames);
}

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

@ -14,8 +14,7 @@ import java.io.StringReader;
import java.util.Vector;
import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.bytecode.ClassFile;
import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.myexception.JVMCodeException;
@ -142,7 +141,7 @@ public class MyCompiler implements MyCompilerAPI
* @param className Klassenname der aktuell betrachteten Klasse
* @param Parameter Parameter der Superklasse
* @param KlassenVektor
*/
// ino.end
// ino.method.wandleGeneric2RefType.21289.definition
public static void wandleGeneric2RefType(Vector<Type> Parameter, Vector<Class> KlassenVektor )
@ -220,7 +219,7 @@ public class MyCompiler implements MyCompilerAPI
} //end for
} //end wandleGeneric2RefType
// ino.end
*/
// ino.method.parse.21292.defdescription type=javadoc
@ -513,14 +512,12 @@ public class MyCompiler implements MyCompilerAPI
// ino.end
// 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){
throw new NullPointerException("Es wurde noch kein Abstrakter Syntaxbaum erstellt!");
}
inferencelog.info("##########################################");
inferencelog.info("# TypeReconstruction-Algorithmus - START #");
inferencelog.info("##########################################\n");
inferencelog.info("##########################################", Section.TYPEINFERENCE);
inferencelog.info("# TypeReconstruction-Algorithmus - START #", Section.TYPEINFERENCE);
inferencelog.info("##########################################\n", Section.TYPEINFERENCE);
TypeAssumptions globalAssumptions = makeFunNAssumptions();
Vector<TypeinferenceResultSet> result = new Vector<TypeinferenceResultSet>();
@ -529,9 +526,9 @@ public class MyCompiler implements MyCompilerAPI
}
inferencelog.info("#########################################");
inferencelog.info("# TypeReconstruction-Algorithmus - ENDE #");
inferencelog.info("#########################################\n");
inferencelog.info("#########################################", Section.TYPEINFERENCE);
inferencelog.info("# TypeReconstruction-Algorithmus - ENDE #", Section.TYPEINFERENCE);
inferencelog.info("#########################################\n", Section.TYPEINFERENCE);
return result;
}

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

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

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

@ -3,5 +3,6 @@ package de.dhbwstuttgart.logger;
public enum Section {
TYPEINFERENCE,
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.fehlerausgabe();
if(el.hasMoreElements())
parserlog.debug("");
}
}
// ino.end

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

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

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

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

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

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

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

@ -9,6 +9,7 @@
// user code:
package de.dhbwstuttgart.parser;
import de.dhbwstuttgart.logger.Section;
%%
%char
@ -167,7 +168,7 @@ null {
//">>=" {this.token = new Token(JavaParser.SIGNEDSHIFTRIGHTEQUAL, yytext(), yyline, yychar);return true;}
//">>>=" {this.token = new Token(JavaParser.UNSIGNEDSHIFTRIGHTEQUAL, yytext(), yyline, yychar);return true;}
{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;}

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.syntaxtree.Class;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.syntaxtree.ImportDeclarations;
import de.dhbwstuttgart.syntaxtree.Interface;
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 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;
}
| IDENTIFIER '<' paralist '>'
@ -495,7 +496,7 @@ paralist : IDENTIFIER
RefType t = new RefType( $1.getLexem(),null,$1.getOffset() );
t.set_ParaList( $3.get_ParaList() );
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;
}
| wildcardparameter
@ -512,8 +513,8 @@ paralist : IDENTIFIER
$1.getParalist().addElement(new GenericTypeVar($3.getLexem(), null,$3.getOffset()));
//$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: " + $1.getParalist());
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(), Section.PARSER);
$$=$1;
}
@ -522,7 +523,7 @@ paralist : IDENTIFIER
RefType t = new RefType( $3.getLexem(),null ,$3.getOffset() );
t.set_ParaList( $5.get_ParaList() );
$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;
}
| paralist ',' wildcardparameter
@ -873,7 +874,7 @@ fielddeclaration : type fielddeclarator ';'
|
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;
}
@ -1314,7 +1315,7 @@ referencelongtype : typename parameter
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());
//ausgetauscht PL 05-07-30
@ -1385,13 +1386,13 @@ formalparameter : type variabledeclaratorid
//FP.set_DeclId($5);
$$=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
{
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);
@ -1400,7 +1401,7 @@ formalparameter : type variabledeclaratorid
//Type T = TypePlaceholder.fresh(); //auskommentiert von Andreas Stadelmeier
// 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 );
//FP.set_DeclId($1);
@ -1498,7 +1499,7 @@ integraltype :INT
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());
LVD.setType($1);
LVD.setDeclidVector($2.getDeclIdVector());
@ -1509,7 +1510,7 @@ localvariabledeclaration : type 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());
//auskommentiert von Andreas Stadelmeier (a10023) LVD.setType(TypePlaceholder.fresh());
LVD.setDeclidVector($1.getDeclIdVector());
@ -1648,7 +1649,7 @@ forstatement
assignmentexpression : conditionalexpression
{
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("conditionalexpression");
de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("conditionalexpression", Section.PARSER);
$$=$1;
}
| assignment
@ -1701,7 +1702,7 @@ conditionalexpression :conditionalorexpression
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());
LocalOrFieldVar LOFV = new LocalOrFieldVar($1.getOffset(),$1.getVariableLength());
LOFV.set_UsedId($1);
@ -1709,7 +1710,7 @@ assignment :lefthandside assignmentoperator assignmentexpr
//auskommentiert von Andreas Stadelmeier (a10023) Ass.setType(TypePlaceholder.fresh());
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 );
}
else
@ -1718,7 +1719,7 @@ assignment :lefthandside assignmentoperator assignmentexpr
Bin.set_Expr1(LOFV);
Bin.set_Operator($2);
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());
Ass.set_Expr( LOFV, Bin );
}
@ -1931,7 +1932,7 @@ postdecrementexpression :postfixexpression DECREMENT
methodinvocation:
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());
UsedId udidmeth = new UsedId($1.getOffset());
udidmeth.set_Name((String)(($1.get_Name()).elementAt($1.get_Name().size()-1)));
@ -1961,7 +1962,7 @@ methodinvocation:
}
| 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());
UsedId udidmeth = new UsedId($1.getOffset());
udidmeth.set_Name((String)(($1.get_Name()).elementAt($1.get_Name().size()-1)));
@ -1992,7 +1993,7 @@ methodinvocation:
}
| 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());
// PL 05-08-21 primary ist kein UsedId
@ -2011,7 +2012,7 @@ methodinvocation:
}
| 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());
// 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:
//////////////////////////////
inferencelog.info("Rufe TRStart()...");
inferencelog.info("Rufe TRStart()...", 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.method.istParameterOK.23200.definition
public void istParameterOK( Vector Parameter, Vector<Class> KlassenVektor )
// 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() )
{
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 );
}
else
@ -346,7 +346,7 @@ public void istParameterOK( Vector Parameter, Vector<Class> KlassenVektor )
} // end otth; end if: t = RefType
}
// ino.end
*/
// 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();
}
*/
@Override
public void sc_init_parameterlist(boolean ext) {
this.methode.sc_init_parameterlist(ext);
}
@Override
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
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.method.sc_init_parameterlist.23530.definition
public void sc_init_parameterlist(boolean ext)
// ino.end
@ -157,7 +158,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
}
}
// ino.end
*/
// ino.method.getTypeName.23533.defdescription type=line
// Eine der beiden Funktionen ist ueberflssig. Wer sich daran strt kann die
// get_ReturnType() auf eigene Gefahr lschen.

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

@ -327,7 +327,7 @@ public class SourceFile
for( int i = 0; i < KlassenVektor.size(); 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.
if( tempKlasse.superclassid != null ) { // Klasse hat Superklasse
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();
RefType Subst = null; // Substitution
int nSubstStelle = 0;
inferencelog.debug("nSubstStelleStart" + nSubstStelle + " " + n);
inferencelog.debug("nSubstStelleStart" + nSubstStelle + " " + n, Section.FINITECLOSURE);
// Parameter durchlaufen und nach Typkonstruktor suchen
// #JB# 17.05.2005
@ -407,13 +407,13 @@ public class SourceFile
// ###########################################################
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 )
{
// Typkonstruktor gefunden -> wird nun als Substitution verwendet
Subst = new RefType( (RefType)vPara.elementAt(nSubstStelle) ,-1);
inferencelog.debug( "Ausgangstyp:" + ((RefType)PTypKonst.TA2).getName() );
inferencelog.debug( "RefType = " + ((RefType)vPara.elementAt(nSubstStelle)).getName() );
inferencelog.debug( "Ausgangstyp:" + ((RefType)PTypKonst.TA2).getName() , Section.FINITECLOSURE);
inferencelog.debug( "RefType = " + ((RefType)vPara.elementAt(nSubstStelle)).getName() , Section.FINITECLOSURE);
break; // Einschraenkung - nur fuer ein RefType wird eine Substitution gesucht
}
}
@ -431,8 +431,8 @@ public class SourceFile
Pair PSuchen = vFC.elementAt(t);
if( ((RefType)(PTypKonst.TA2)).getTypeName().equals( ((RefType)PSuchen.TA1).getTypeName() ) )
{
inferencelog.debug(" gefundener Typ links: " + ((RefType)(PSuchen.TA1)).getName() );
inferencelog.debug(" gefundener Typ rechts: " + ((RefType)(PSuchen.TA2)).getName() );
inferencelog.debug(" gefundener Typ links: " + ((RefType)(PSuchen.TA1)).getName(), Section.FINITECLOSURE );
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
// Substitution
//Pair P = new Pair( PSuchen.getTA1Copy( ), PSuchen.getTA2Copy( ) );
@ -470,12 +470,12 @@ public class SourceFile
//TV = new TypePlaceholder( ((RefType)PSuchen.TA1).getParaN(u) );
//System.out.println("TV_Name: " + u + TV.Type2String());
// ###########################################################
inferencelog.debug("Typterm_Name: " + vPara.elementAt(u));
inferencelog.debug("Typterm_Name: " + ((Type)vPara.elementAt(u)).Type2String());
inferencelog.debug("Typterm_Name: " + vPara.elementAt(u), Section.FINITECLOSURE);
inferencelog.debug("Typterm_Name: " + ((Type)vPara.elementAt(u)).Type2String(), Section.FINITECLOSURE);
hts.put(new JavaClassName(((RefType)PSuchen.TA1).getParaN(u)), vPara.elementAt(u));
}
catch( Exception E ) {
inferencelog.error(E.getMessage());
inferencelog.error(E.getMessage(), Section.FINITECLOSURE);
//FIXME Throw Exception or Error instead of exiting!
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 de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.bytecode.ClassFile;
import de.dhbwstuttgart.bytecode.CodeAttribute;
import de.dhbwstuttgart.myexception.CTypeReconstructionException;
@ -171,7 +171,7 @@ public class Block extends Statement
if(statements.size()==0)this.setType(new Void(this,0));
/* this.setTypeVariable(TypePlaceholder.fresh(this)); */
for(Statement stmt : statements){
typinferenceLog.debug("Prozessing statement: "+stmt);
typinferenceLog.debug("Prozessing statement: "+stmt, Section.TYPEINFERENCE);
ret.add(stmt.TYPEStmt(assumptions));
/* if((stmt instanceof Return)){
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){
Statement stmt = statements.elementAt(statements.size()-1);
typinferenceLog.debug("Prozessing statement: "+stmt);
typinferenceLog.debug("Prozessing statement: "+stmt, Section.TYPEINFERENCE);
this.setType(stmt.getType());
for(int i= statements.size()-2; i >= 0; i--) {
stmt = statements.elementAt(i);
typinferenceLog.debug("Prozessing statement: "+stmt);
typinferenceLog.debug("Prozessing statement: "+stmt, Section.TYPEINFERENCE);
if (!(stmt.getReturnType() instanceof Void))
if (this.getReturnType() instanceof Void) {
//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.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)
// ino.end
@ -66,7 +66,7 @@ public class BoolLiteral extends Literal
}
}
// ino.end
*/
// 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.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)
// ino.end
@ -63,7 +63,7 @@ public class CharLiteral extends Literal
parserlog.debug(" ---CharLiteral---");
}
// ino.end
*/
// ino.method.set_Char.25182.definition
public void set_Char( char c)
// ino.end

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

@ -73,6 +73,7 @@ public class DoubleLiteral extends Literal
}
// ino.end
/*
// 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)
// ino.end
@ -81,6 +82,7 @@ public class DoubleLiteral extends Literal
parserlog.debug("SC -> Semantik-Check f<>r DoubleLiteral wurde aufgerufen --> nichts zu tun!");
}
// ino.end
*/
// ino.method.get_Name.25469.definition
public String get_Name()

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

@ -42,6 +42,7 @@ public class EmptyStmt extends Statement
// ino.attribute.parserlog.25210.declaration
protected static Logger parserlog = Logger.getLogger("parser");
// ino.end
/*
// 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)
// ino.end
@ -52,6 +53,7 @@ public class EmptyStmt extends Statement
}
}
// ino.end
*/
// ino.method.codegen.25216.definition
public void codegen(ClassFile classfile, CodeAttribute code, Vector paralist)

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

@ -68,6 +68,7 @@ public class FloatLiteral extends Literal
}
// ino.end
/*
// 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)
// ino.end
@ -76,6 +77,7 @@ public class FloatLiteral extends Literal
parserlog.debug("SC -> Semantik-Check f<>r FloatLiteral wurde aufgerufen --> nichts zu tun!");
}
// ino.end
*/
// ino.method.get_Name.25469.definition
public String get_Name()

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));
}
/*
// 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)
// ino.end
@ -142,7 +143,7 @@ public class InstVar extends Expr
}
}
// ino.end
*/
// ino.method.get_Name.25420.definition
public String get_Name()
// ino.end
@ -188,7 +189,9 @@ public class InstVar extends Expr
// ino.end
// 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

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

@ -71,6 +71,7 @@ public class IntLiteral extends Literal
}
// ino.end
/*
// 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)
// ino.end
@ -79,6 +80,7 @@ public class IntLiteral extends Literal
parserlog.debug("SC -> Semantik-Check f<>r IntLiteral wurde aufgerufen --> nichts zu tun!");
}
// ino.end
*/
// ino.method.get_Name.25469.definition
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.method.check_anz.25590.definition
public void check_anz(Type type, Vector paralist, Vector<Class> classlist)
throws SCStatementException
@ -243,7 +244,7 @@ public class LocalVarDecl extends Statement implements TypeInsertable
}
// ino.end
*/

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

@ -72,6 +72,7 @@ public class LongLiteral extends Literal
}
// ino.end
/*
// 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)
// ino.end
@ -80,6 +81,7 @@ public class LongLiteral extends Literal
parserlog.debug("SC -> Semantik-Check f<>r LongLiteral wurde aufgerufen --> nichts zu tun!");
}
// ino.end
*/
// ino.method.get_Name.25469.definition
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.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)
// ino.end
@ -97,6 +98,7 @@ public class NewArray extends Expr
parserlog.debug(" ---NewArray---");
}
// ino.end
*/
// ino.method.get_codegen_Array_Type.25815.definition
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.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)
// ino.end
@ -64,6 +65,7 @@ public class Null extends Literal
parserlog.debug(" ---Null---");
}
// ino.end
*/
// ino.method.codegen.25935.definition
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.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)
// ino.end
@ -86,6 +87,7 @@ public class PositivExpr extends UnaryExpr
//Wartet noch auf Implementierung
}
// ino.end
*/
// ino.method.codegen.25975.definition
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.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)
// ino.end
@ -64,6 +65,7 @@ public class StringLiteral extends Literal
parserlog.debug(" ---StringLiteral---");
}
// ino.end
*/
// ino.method.set_String.26243.definition
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.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)
throws SCStatementException
@ -88,6 +88,7 @@ public class This extends Expr
parserlog.debug(" ---This---");
}
// ino.end
*/
// ino.method.codegen.26283.definition
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.module.ParaList.8674.import
import java.util.Vector;
import de.dhbwstuttgart.logger.Logger;
// ino.end
import de.dhbwstuttgart.logger.Section;
@ -32,7 +34,7 @@ public class ParaList extends Vector<Type>
// ino.end
// ino.method.ParaList.26603.body
{
parserlog.debug( "ParaList: " + t );
parserlog.debug( "ParaList: " + t, Section.PARSER );
this.addElement(t);
}
// ino.end
@ -52,7 +54,6 @@ public class ParaList extends Vector<Type>
// ino.method.add_ParaList.26609.body
{
this.addElement(obj);
parserlog.debug("ParaList: " + obj);
}
// 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.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.core.IItemWithOffset;
import de.dhbwstuttgart.myexception.SCException;
@ -346,6 +347,7 @@ public class RefType extends Type implements IMatchable
// ino.end
public Vector<Type> getParaList(){
if(this.parameter==null)return new Vector<>();
return this.parameter;
}
@ -806,6 +808,13 @@ public class RefType extends Type implements IMatchable
return t;
}
@Override
public Vector<SyntaxTreeNode> getChildren() {
Vector<SyntaxTreeNode> ret = super.getChildren();
ret.addAll(this.getParaList());
return ret;
}
@Override
public Type checkTYPE(TypeAssumptions ass, SyntaxTreeNode method) {
Type t = ass.checkType(this, parent);

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

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

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

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

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.Vector;
import org.antlr.v4.tool.ast.SetAST;
import de.dhbwstuttgart.core.IItemWithOffset;
import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.parser.JavaClassName;
import de.dhbwstuttgart.syntaxtree.Class;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
@ -363,7 +366,7 @@ public class TypeAssumptions {
*/
public ConstructorAssumption getConstructorAssumption(String name, int size) {
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;
}
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 de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.core.IItemWithOffset;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar;
@ -81,7 +81,7 @@ public class TypeInsertSet {
}
}
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(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.Iterator;
import java.util.Vector;
import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.logger.SectionLogger;
import de.dhbwstuttgart.core.MyCompiler;
import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.myexception.MatchException;
@ -46,7 +49,7 @@ public class Unify
{
// ino.attribute.inferencelog.28052.declaration
protected static Logger inferencelog = Logger.getLogger("inference");
protected static SectionLogger inferencelog = Logger.getSectionLogger("inference", Section.UNIFY);
// ino.end
/**
@ -1068,10 +1071,6 @@ throws MatchException
for(int i=0; i < FCtype.get_ParaList().size(); i++) {
if (FCtype.get_ParaList().elementAt(i) instanceof GenericTypeVar) {
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(),
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 de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.LoggerConfiguration;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.core.MyCompiler;
import de.dhbwstuttgart.core.MyCompilerAPI;
import de.dhbwstuttgart.parser.JavaParser.yyException;
@ -26,7 +27,7 @@ public class TypeInsertTester{
private static Logger inferencelog = Logger.getLogger(TypeInsertTester.class.getName());
static{
{
Logger.setStandardOutput(System.out);
Logger.setStandardConfiguration(new LoggerConfiguration().setOutput(Section.TYPEINFERENCE, System.out));
/*
// Ausgabeoptionen fuer die Logger
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_FILE2 = "GenericTypeVarTest2.jav";
/*
@Test
public void run(){
Vector<String> mustContain = new Vector<String>();
mustContain.add("String methode");
MultipleTypesInsertTester.test(this.TEST_FILE, mustContain);
}
*/
@Test
public void run2(){
Vector<String> mustContain = new Vector<String>();

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

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

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

@ -11,7 +11,7 @@ public class LambdaTest4 {
@Test
public void run(){
Vector<String> mustContain = new Vector<String>();
mustContain.add("String var");
//mustContain.add("String var");
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.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.typeinference.TypeinferenceResultSet;
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 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){
String gesamterSrc = "";
String inferedSource = "";
@ -24,6 +32,7 @@ public class MultipleTypesInsertTester extends TypeInsertTester{
try {
compiler.parse(new File(rootDirectory + sourceFileToInfere));
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);
for(TypeinferenceResultSet result : results){
TypeInsertSet point = result.getTypeInsertionPoints();