2013-10-18 11:33:46 +00:00
// ino.module.Class.8553.package
2014-09-02 08:33:54 +00:00
package de.dhbwstuttgart.syntaxtree ;
2013-10-18 11:33:46 +00:00
// ino.end
// ino.module.Class.8553.import
import java.util.ArrayList ;
import java.util.Collection ;
import java.util.Enumeration ;
import java.util.Hashtable ;
import java.util.Iterator ;
2016-03-20 17:55:36 +00:00
import java.util.LinkedList ;
import java.util.List ;
2015-05-21 15:10:04 +00:00
2015-10-23 14:22:44 +00:00
import javax.lang.model.element.Modifier ;
2016-07-21 14:36:33 +00:00
import org.apache.bcel.generic.ClassGen ;
import org.apache.bcel.generic.ConstantPoolGen ;
import org.apache.bcel.generic.InstructionFactory ;
import org.apache.bcel.generic.InstructionHandle ;
import org.apache.bcel.generic.InstructionList ;
import org.apache.bcel.generic.MethodGen ;
2015-05-21 15:10:04 +00:00
2014-10-09 10:01:16 +00:00
import de.dhbwstuttgart.logger.Logger ;
2014-10-09 15:38:10 +00:00
import de.dhbwstuttgart.logger.Section ;
2015-05-27 13:57:15 +00:00
import de.dhbwstuttgart.logger.SectionLogger ;
2015-09-02 15:11:32 +00:00
import de.dhbwstuttgart.bytecode.ClassGenerator ;
2015-09-10 14:21:30 +00:00
import de.dhbwstuttgart.bytecode.DHBWConstantPoolGen ;
import de.dhbwstuttgart.bytecode.DHBWInstructionFactory ;
2014-09-02 08:33:54 +00:00
import de.dhbwstuttgart.core.IItemWithOffset ;
2014-09-05 09:49:31 +00:00
import de.dhbwstuttgart.parser.JavaClassName ;
import de.dhbwstuttgart.syntaxtree.modifier.Modifiers ;
2015-10-23 14:22:44 +00:00
import de.dhbwstuttgart.syntaxtree.modifier.Static ;
2014-09-02 08:33:54 +00:00
import de.dhbwstuttgart.syntaxtree.statement.Block ;
import de.dhbwstuttgart.syntaxtree.statement.Expr ;
import de.dhbwstuttgart.syntaxtree.statement.Statement ;
2015-06-16 15:44:27 +00:00
import de.dhbwstuttgart.syntaxtree.statement.SuperCall ;
2014-09-02 08:33:54 +00:00
import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar ;
import de.dhbwstuttgart.syntaxtree.type.RefType ;
import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType ;
import de.dhbwstuttgart.syntaxtree.type.Type ;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder ;
import de.dhbwstuttgart.syntaxtree.type.WildcardType ;
import de.dhbwstuttgart.typeinference.* ;
import de.dhbwstuttgart.typeinference.assumptions.ClassAssumption ;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions ;
import de.dhbwstuttgart.typeinference.exceptions.DebugException ;
2015-05-27 13:57:15 +00:00
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException ;
2014-09-02 08:33:54 +00:00
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException ;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertPoint ;
2016-04-13 16:32:09 +00:00
import de.dhbwstuttgart.typeinference.unify.TypeUnify ;
2015-05-27 13:57:15 +00:00
2016-07-21 14:36:33 +00:00
import org.apache.bcel.generic.* ;
import org.apache.bcel.classfile.* ;
import org.apache.bcel.* ;
2015-05-27 13:57:15 +00:00
2015-05-21 15:10:04 +00:00
import java.io.* ;
2013-10-18 11:33:46 +00:00
2015-05-22 11:50:43 +00:00
2016-09-09 22:40:17 +00:00
/ * *
* Stellt jede Art von Klasse dar . Auch abstrakte Klassen und Interfaces
* /
public class Class extends GTVDeclarationContext implements IItemWithOffset , Generic , GenericTypeInsertable
2013-10-18 11:33:46 +00:00
{
2014-02-12 01:12:12 +00:00
/ * *
* Log4j - Loggerinstanzen
* /
protected static Logger inferencelog = Logger . getLogger ( " inference " ) ;
2015-06-16 09:55:15 +00:00
protected static Logger codegenlog = Logger . getLogger ( " codegen " ) ;
protected static Logger parserlog = Logger . getLogger ( " parser " ) ;
2016-09-09 22:40:17 +00:00
protected Logger typinferenzLog = Logger . getLogger ( Class . class . getName ( ) ) ;
2014-02-12 01:12:12 +00:00
protected Modifiers modifiers ;
2016-09-09 22:40:17 +00:00
protected JavaClassName name ;
public Class ( JavaClassName name , List < Method > methoden , List < Field > felder , Modifiers modifier ,
boolean isInterface , RefType superClass , List < RefType > implementedInterfaces , int offset ) {
2016-09-16 11:25:20 +00:00
super ( offset ) ;
2016-09-09 22:40:17 +00:00
}
2015-05-21 15:10:04 +00:00
2016-10-28 16:31:42 +00:00
protected List < RefType > implementedInterfaces = new ArrayList < > ( ) ;
2015-05-21 15:10:04 +00:00
2015-09-02 15:11:32 +00:00
/ * *
*
* @param resultSet - Fehlende Typen im Syntaxbaum werden nach diesem ResultSet aufgelöst
* @return
* /
2015-11-06 15:42:22 +00:00
public ByteCodeResult genByteCode ( TypeinferenceResults typeinferenceResults ) {
2015-09-02 15:11:32 +00:00
InstructionFactory _factory ;
2015-09-10 14:21:30 +00:00
DHBWConstantPoolGen _cp ;
2015-09-02 15:11:32 +00:00
ClassGenerator _cg ;
2015-10-16 08:39:34 +00:00
Menge < ByteCodeResult > results = new Menge < ByteCodeResult > ( ) ;
2015-05-27 13:57:15 +00:00
SectionLogger logger = Logger . getSectionLogger ( this . getClass ( ) . getName ( ) , Section . CODEGEN ) ;
logger . debug ( " Test " ) ;
if ( pkgName ! = null ) throw new NotImplementedException ( ) ;
2016-10-28 16:31:42 +00:00
short constants = Const . ACC_PUBLIC ; //Per Definition ist jede Methode public
if ( isInterface ( ) ) constants + = Const . ACC_INTERFACE ;
_cg = new ClassGenerator ( name , this . getSuperClass ( ) , this . getGenericParameter ( ) , name + " .java " , constants , new String [ ] { } , typeinferenceResults ) ; //letzter Parameter sind implementierte Interfaces
2015-05-22 11:50:43 +00:00
_cp = _cg . getConstantPool ( ) ;
2015-09-10 14:21:30 +00:00
_factory = new DHBWInstructionFactory ( _cg , _cp ) ;
2015-09-02 15:11:32 +00:00
//Die Felder in Methoden Felder und Konstruktoren aufteilen:
Menge < FieldDeclaration > fieldDeclarations = new Menge < > ( ) ;
Menge < Constructor > constructors = new Menge < > ( ) ;
Menge < Method > methods = new Menge < > ( ) ;
2015-05-27 13:57:15 +00:00
for ( Field field : this . fielddecl ) {
2015-09-02 15:11:32 +00:00
if ( field instanceof Constructor ) constructors . add ( ( Constructor ) field ) ;
if ( field instanceof Method & & ! ( field instanceof Constructor ) ) methods . add ( ( Method ) field ) ;
if ( field instanceof FieldDeclaration ) fieldDeclarations . add ( ( FieldDeclaration ) field ) ;
//field.genByteCode(_cg);
2015-05-27 13:57:15 +00:00
}
2016-10-28 16:31:42 +00:00
2015-09-02 15:11:32 +00:00
//Zuerst die Methoden und Felder abarbeiten:
for ( Method m : methods ) {
2016-10-07 12:12:18 +00:00
m . genByteCode ( _cg , this , typeinferenceResults ) ;
2015-09-02 15:11:32 +00:00
}
InstructionList fieldInitializations = new InstructionList ( ) ;
for ( FieldDeclaration f : fieldDeclarations ) {
2016-10-07 12:12:18 +00:00
//Die Felder können noch nicht überladen werden. Hier ist nur die erste der Lösungen möglich:
2016-04-29 14:03:38 +00:00
fieldInitializations . append ( f . genByteCode ( _cg , typeinferenceResults . getTypeReconstructions ( ) . get ( 0 ) ) ) ;
2015-09-02 15:11:32 +00:00
}
//Die Konstruktoren müssen die Feld initialisierungswerte beinhalten:
for ( Constructor c : constructors ) {
c . genByteCode ( _cg , fieldInitializations ) ;
}
2015-05-27 13:57:15 +00:00
2015-10-22 18:40:33 +00:00
return new ByteCodeResult ( _cg ) ;
2015-05-22 11:50:43 +00:00
}
2016-09-09 22:40:17 +00:00
2014-09-02 16:49:19 +00:00
public JavaClassName getName ( )
2014-02-12 01:12:12 +00:00
{
2014-09-02 16:49:19 +00:00
return new JavaClassName ( ( this . pkgName ! = null ? this . pkgName . toString ( ) + " . " : " " ) + this . name ) ;
2014-02-12 01:12:12 +00:00
}
public void setName ( String strName )
{
2016-10-28 16:31:42 +00:00
name = new JavaClassName ( strName ) ;
2014-02-12 01:12:12 +00:00
}
public void setModifiers ( Modifiers mod )
{
this . modifiers = mod ;
}
public Modifiers getModifiers ( )
{
return this . modifiers ;
}
/ * *
* Liefert die AccessFlags fuer den Bytecode zurueck .
* /
public short getAccessFlags ( )
{
short ret = 0 ;
if ( modifiers ! = null ) {
ret = modifiers . calculate_access_flags ( ) ;
}
return ret ;
}
2014-09-14 16:38:43 +00:00
2016-09-09 22:40:17 +00:00
public Menge < RefType > getSuperInterfaces ( )
2014-02-12 01:12:12 +00:00
{
return superif ;
}
2016-04-06 10:42:15 +00:00
2013-10-18 11:33:46 +00:00
private Block class_block ;
2016-04-06 10:42:15 +00:00
2013-10-18 11:33:46 +00:00
private Hashtable < String , String > parahash = new Hashtable < String , String > ( ) ; // parametrisierten Attrib. werden mit den Paramet.aus paralist verk.
2015-05-12 17:49:27 +00:00
private TypeAssumptions typeAssumptions = null ; //muss mit null Initialisiert werden. Darf nur über getTypeAssumptions abgerufen werden.
2013-10-18 11:33:46 +00:00
2015-04-22 19:40:22 +00:00
private Menge < Field > fielddecl = new Menge < Field > ( ) ;
2014-06-25 15:30:31 +00:00
private GenericDeclarationList genericClassParameters ;
2014-07-16 12:35:12 +00:00
private int offset ;
2016-03-22 12:17:56 +00:00
private RefType superClass ;
2013-10-18 11:33:46 +00:00
2015-04-22 19:40:22 +00:00
public Menge < Field > getFields ( )
2014-02-14 16:31:55 +00:00
{
return fielddecl ;
}
2014-10-08 17:00:17 +00:00
2013-10-18 11:33:46 +00:00
// ino.method.get_ParaList.23101.definition
2016-04-18 13:38:47 +00:00
public List < ? extends Type > get_ParaList ( )
2013-10-18 11:33:46 +00:00
// ino.end
// ino.method.get_ParaList.23101.body
{
2015-04-22 19:40:22 +00:00
//if(this.paralist == null)return new Menge<Type>();
2016-09-16 11:25:20 +00:00
return this . getGenericParameter ( ) . getGTVList ( ) ;
2013-10-18 11:33:46 +00:00
}
// ino.end
// ino.method.set_ParaHash.23104.definition
public void set_ParaHash ( Hashtable < String , String > hash )
// ino.end
// ino.method.set_ParaHash.23104.body
{
this . parahash = hash ;
}
// ino.end
// ino.method.get_ParaHash.23107.definition
public Hashtable < String , String > get_ParaHash ( )
// ino.end
// ino.method.get_ParaHash.23107.body
{
return this . parahash ;
}
/////////////////////////////////////////////////////////////////////////
// TypeReconstructionAlgorithmus
/////////////////////////////////////////////////////////////////////////
// ino.method.TRProg.23110.defdescription type=javadoc
/ * *
2015-05-12 17:49:27 +00:00
* Ausgangspunkt fà ¯  ¿  ½ r den Typrekonstruktionsalgorithmus . Hier werden zunà ¯  ¿  ½ chst
2013-10-18 11:33:46 +00:00
* die Mengen von Typannahmen V_fields_methods und V_i erstellt , die als Eingabe
2015-05-12 17:49:27 +00:00
* fà ¯  ¿  ½ r den Algorithmus dienen . < br / >
* ( siehe Algorithmus 5 . 17 TRProg , Martin Plà ¯  ¿  ½ micke )
* < br / > Author : JÃ ¯ Â ¿ Â ½ rg BÃ ¯ Â ¿ Â ½ uerle
2013-10-18 11:33:46 +00:00
* @param supportData
* @param globalAssumptions
2015-05-12 17:49:27 +00:00
* @return Liste aller bisher berechneten , mà ¯  ¿  ½ glichen Typkombinationen
2013-10-18 11:33:46 +00:00
* @throws CTypeReconstructionException
* /
// ino.end
// ino.method.TRProg.23110.definition
2016-03-24 10:57:17 +00:00
public ConstraintsSet typeReconstruction ( TypeAssumptions globalAssumptions )
2013-10-18 11:33:46 +00:00
// ino.end
// ino.method.TRProg.23110.body
{
2014-09-04 14:35:44 +00:00
/ *
* /
2013-10-18 11:33:46 +00:00
//////////////////////////////
// Und los geht's:
//////////////////////////////
2014-11-04 12:47:05 +00:00
inferencelog . info ( " Rufe TRStart()... " , Section . TYPEINFERENCE ) ;
2014-09-02 16:49:19 +00:00
2016-03-24 10:57:17 +00:00
//////////////////////////////
2013-10-18 11:33:46 +00:00
// Ab hier ...
// @author A10023 - Andreas Stadelmeier:
//////////////////////////////
//Erzeuge Assumptions:
2014-03-19 14:14:50 +00:00
TypeAssumptions assumptions = this . getPrivateFieldAssumptions ( ) ;
2015-05-12 17:49:27 +00:00
//Globale Assumptions anfügen:
2013-10-18 11:33:46 +00:00
assumptions . add ( globalAssumptions ) ;
2014-06-18 11:37:17 +00:00
ConstraintsSet oderConstraints = new ConstraintsSet ( ) ;
2015-06-17 10:03:54 +00:00
2014-10-08 17:00:17 +00:00
for ( Type gparam : this . get_ParaList ( ) ) {
2015-05-12 17:49:27 +00:00
if ( gparam instanceof GenericTypeVar ) assumptions . add ( ( ( GenericTypeVar ) gparam ) . createAssumptions ( ) ) ; //Constraints für die Generischen Variablen erstellen und diese dem AssumptionsSet hinzufügen
2014-07-17 18:17:59 +00:00
}
2014-10-08 17:00:17 +00:00
for ( Type gparam : this . get_ParaList ( ) ) {
2015-05-12 17:49:27 +00:00
if ( gparam instanceof GenericTypeVar ) oderConstraints . add ( ( ( GenericTypeVar ) gparam ) . TYPE ( assumptions ) ) ; //Constraints für die Generischen Variablen erstellen und diese dem AssumptionsSet hinzufügen
2014-06-18 09:30:14 +00:00
}
2014-10-09 15:38:10 +00:00
typinferenzLog . debug ( " Erstellte Assumptions: " + assumptions , Section . TYPEINFERENCE ) ;
2016-09-09 22:40:17 +00:00
2016-03-22 12:17:56 +00:00
//Gibt es hier eine ClassCastException stimmt etwas grundsätzlich nicht!
2016-09-09 22:40:17 +00:00
//this.superClass = (RefType)this.superClass.TYPE(assumptions, this);
2015-06-17 10:03:54 +00:00
2014-02-14 16:31:55 +00:00
for ( Field f : this . getFields ( ) ) {
2014-02-12 21:10:33 +00:00
oderConstraints . add ( f . TYPE ( assumptions ) ) ;
}
2014-10-09 15:38:10 +00:00
typinferenzLog . debug ( " Erstellte Constraints: " + oderConstraints , Section . TYPEINFERENCE ) ;
2013-10-18 11:33:46 +00:00
2014-02-11 01:47:39 +00:00
return oderConstraints ;
2013-10-18 11:33:46 +00:00
}
2014-02-19 04:20:54 +00:00
2013-10-18 11:33:46 +00:00
/ * *
2015-05-12 17:49:27 +00:00
* Ermittelt alle privaten Felder und Methoden der Klasse und Erstellt eine Assumption fà ¼ r diese .
* Bemerkung : Momentan werden noch alle Felder dieser Klasse zurà ¼ ckgegeben .
2013-10-18 11:33:46 +00:00
* @return Die erstellten TypeAssumptions
* /
2014-03-19 14:14:50 +00:00
private TypeAssumptions getPrivateFieldAssumptions ( ) {
2015-05-12 17:49:27 +00:00
if ( this . typeAssumptions ! = null ) return this . typeAssumptions ; //Das sorgt dafür, dass die Assumptions nur einmalig generiert werden.
2013-10-18 11:33:46 +00:00
TypeAssumptions assumptions = new TypeAssumptions ( this . getName ( ) ) ;
2014-02-14 16:31:55 +00:00
for ( Field field : this . getFields ( ) ) {
2014-04-14 16:05:24 +00:00
if ( ! field . isPublic ( ) ) assumptions . add ( field . createTypeAssumptions ( this ) ) ;
2013-10-18 11:33:46 +00:00
}
2015-05-12 17:49:27 +00:00
this . typeAssumptions = assumptions ; //Diese müssen anschlieà end nicht wieder generiert werden.
2013-10-18 11:33:46 +00:00
return assumptions ;
2015-10-16 08:39:34 +00:00
}
2014-09-05 09:49:31 +00:00
2013-10-18 11:33:46 +00:00
/ * *
2015-05-12 17:49:27 +00:00
* < br / > Author : Martin Plà ¯  ¿  ½ micke
2013-10-18 11:33:46 +00:00
* @return
* /
public String toString ( )
{
2016-11-11 10:01:55 +00:00
return name . toString ( ) ;
2013-10-18 11:33:46 +00:00
}
2015-04-22 19:40:22 +00:00
public String getTypeInformation ( Menge < Method > methodList , Menge < Expr > fieldList ) {
2013-10-18 11:33:46 +00:00
String ret = this . name + " : " ;
for ( Expr field : fieldList ) {
ret + = field . getTypeInformation ( ) + " \ n " ;
}
for ( Method m : methodList ) {
ret + = m . getTypeInformation ( ) + " \ n " ;
}
return ret ;
}
/ * *
2015-05-12 17:49:27 +00:00
* Generiert den JavaCode dieser Klasse im Falle fà ¼ r das à ¼ bergebene resultSet .
2013-10-18 11:33:46 +00:00
* Dem ResultSet entsprechend werden in diesem Java - Code die TypePlaceholder durch die in ResultSet stehenden Typen ersetzt .
* @return Java - Sourcefile
* /
2016-09-30 10:46:02 +00:00
public JavaCodeResult printJavaCode ( ResultSet reconstructionResult ) {
2013-10-18 11:33:46 +00:00
JavaCodeResult ret = new JavaCodeResult ( " class " ) ;
JavaCodeResult classBodyCode = new JavaCodeResult ( ) ;
2016-09-30 10:46:02 +00:00
if ( this . modifiers ! = null ) classBodyCode . attach ( this . modifiers . printJavaCode ( reconstructionResult ) ) . attach ( " " ) ;
2013-10-18 11:33:46 +00:00
2016-09-30 10:46:02 +00:00
classBodyCode . attach ( this . name + " extends " ) . attach ( this . superClass . printJavaCode ( reconstructionResult ) ) . attach ( " \ n " ) ;
2014-02-14 16:31:55 +00:00
JavaCodeResult bodyString = new JavaCodeResult ( " { \ n " ) ;
2016-09-30 10:46:02 +00:00
for ( Field field : this . fielddecl ) bodyString . attach ( field . printJavaCode ( reconstructionResult ) ) . attach ( " \ n " ) ;
2014-02-14 16:31:55 +00:00
bodyString . attach ( " } \ n " ) ;
2016-09-09 22:40:17 +00:00
2013-10-18 11:33:46 +00:00
classBodyCode . attach ( bodyString ) ;
2015-05-12 17:49:27 +00:00
//Zuerst die generischen Parameter für diese Klasse berechnen:
2014-07-09 08:52:23 +00:00
//this.createGenericTypeVars(classBodyCode.getUnresolvedTPH());
2013-10-18 11:33:46 +00:00
if ( this . genericClassParameters ! = null & & this . genericClassParameters . size ( ) > 0 ) {
ret . attach ( " < " ) ;
Iterator < GenericTypeVar > it = this . genericClassParameters . iterator ( ) ;
while ( it . hasNext ( ) ) {
GenericTypeVar tph = it . next ( ) ;
2016-09-30 10:46:02 +00:00
ret . attach ( tph . printJavaCode ( reconstructionResult ) ) ;
2013-10-18 11:33:46 +00:00
if ( it . hasNext ( ) ) ret . attach ( " , " ) ;
}
ret . attach ( " > " ) ;
}
String stringReturn = ret . attach ( classBodyCode ) . toString ( ) ;
2016-09-30 10:46:02 +00:00
return new JavaCodeResult ( stringReturn ) ;
2013-10-18 11:33:46 +00:00
}
/ * *
2015-05-12 17:49:27 +00:00
* Errechnet die Generischen Parameter der Klasse fà ¼ r diese Klasse .
* Die berechneten Variablen werden anschlieà end in die this . genericTypeVars eingesetzt . Dabei werden alte genericTypeVars à ¼ berschrieben .
* @param tphs : Alle à ¼ briggebliebenen TypePLaceholder
2014-07-09 08:52:23 +00:00
2015-04-22 19:40:22 +00:00
private void createGenericTypeVars ( Menge < TypePlaceholder > tphs ) {
this . genericClassParameters = new GenericDeclarationList ( new Menge < GenericTypeVar > ( ) ) ;
2013-10-18 11:33:46 +00:00
for ( TypePlaceholder tph : tphs ) {
2014-04-16 14:02:16 +00:00
GenericTypeVar toAdd = new GenericTypeVar ( tph , this . getOffset ( ) ) ;
2013-10-18 11:33:46 +00:00
if ( ! this . genericClassParameters . contains ( toAdd ) ) this . genericClassParameters . add ( toAdd ) ;
}
}
2014-07-09 08:52:23 +00:00
* /
2013-10-18 11:33:46 +00:00
/ * *
2015-05-12 17:49:27 +00:00
* Errechnet die Generischen Parameter der Klasse fà ¼ r diese Klasse .
* Die berechneten Variablen werden anschlieà end in die this . genericTypeVars eingesetzt . Dabei werden alte genericTypeVars à ¼ berschrieben .
2013-10-18 11:33:46 +00:00
* @param reconstructionResult
2014-06-18 09:30:14 +00:00
2014-02-09 15:07:31 +00:00
public void createGenericTypeVars ( TypeinferenceResultSet reconstructionResult ) {
2015-04-22 19:40:22 +00:00
this . genericClassParameters = new Menge < GenericTypeVar > ( ) ;
2013-10-18 11:33:46 +00:00
for ( Pair pair : reconstructionResult . getUnifiedConstraints ( ) ) {
if ( pair . TA2 instanceof TypePlaceholder & & pair . TA1 instanceof TypePlaceholder ) { // if(pair.OperatorSmallerExtends() || pair.OperatorSmaller()){
Type ta1 = reconstructionResult . getUnifiedConstraints ( ) . getTypeEqualTo ( pair . TA1 ) ;
Type ta2 = reconstructionResult . getUnifiedConstraints ( ) . getTypeEqualTo ( pair . TA2 ) ;
2014-04-16 14:02:16 +00:00
this . genericClassParameters . add ( new GenericTypeVar ( new Pair ( ta1 , ta2 ) , this . getOffset ( ) ) ) ;
2013-10-18 11:33:46 +00:00
}
}
for ( Pair pair : reconstructionResult . getConstraints ( ) ) {
if ( ! reconstructionResult . getUnifiedConstraints ( ) . contains ( pair . TA1 ) ) {
2014-04-16 14:02:16 +00:00
this . genericClassParameters . add ( new GenericTypeVar ( pair . TA1 , this . getOffset ( ) ) ) ;
2013-10-18 11:33:46 +00:00
}
if ( ! reconstructionResult . getUnifiedConstraints ( ) . contains ( pair . TA2 ) ) {
2014-04-16 14:02:16 +00:00
this . genericClassParameters . add ( new GenericTypeVar ( pair . TA2 , this . getOffset ( ) ) ) ;
2013-10-18 11:33:46 +00:00
}
}
}
2014-06-18 09:30:14 +00:00
* /
2014-04-16 14:02:16 +00:00
public int getOffset ( ) {
2014-07-16 12:35:12 +00:00
return this . offset ;
2014-04-16 14:02:16 +00:00
}
2013-10-18 11:33:46 +00:00
/ * *
* Erstellt einen RefType , welcher auf diese Klasse verweist
2014-04-09 12:12:55 +00:00
* Ersetzt alle Generischen Variablen in der Parameterliste mit TPH
2013-10-18 11:33:46 +00:00
* @return
* /
public RefType getType ( ) {
2014-06-18 11:37:17 +00:00
/ *
2015-04-22 19:40:22 +00:00
Menge < Type > parameter = new Menge < Type > ( ) ;
2014-03-28 17:36:08 +00:00
for ( Type param : this . get_ParaList ( ) ) {
parameter . add ( ( ( GenericTypeVar ) param ) . getTypePlaceHolder ( ) ) ; //(TypePlaceholder.fresh()); //Hier ist kein ReplacementListener notwendig. Der Typ soll nie eingesetzt werden. Der TPH wird nur gebraucht, damit das Unifizieren funktioniert.
}
2014-06-18 11:37:17 +00:00
* /
2014-09-14 16:38:43 +00:00
return new RefType ( this . getName ( ) . toString ( ) , this . get_ParaList ( ) , this , 0 ) ;
2013-10-18 11:33:46 +00:00
}
/ * *
* Ermittelt die Sichtbaren Felder und Methoden der Klasse .
* ( Momentan sind im Projekt alle Felder und Methoden " package private " , da der Parser keine Access - Modifier einlesen kann .
* @return
* /
public TypeAssumptions getPublicFieldAssumptions ( ) {
2014-04-14 16:05:24 +00:00
TypeAssumptions ret = new TypeAssumptions ( ) ; //this.getPrivateFieldAssumptions();
2014-04-09 12:12:55 +00:00
ret . addClassAssumption ( new ClassAssumption ( this ) ) ;
2014-02-19 13:16:28 +00:00
for ( Field f : this . getFields ( ) ) {
2014-04-14 16:05:24 +00:00
if ( f . isPublic ( ) ) ret . add ( f . createTypeAssumptions ( this ) ) ;
2014-02-19 13:16:28 +00:00
}
2014-09-18 14:26:02 +00:00
for ( GenericTypeVar gtv : this . getGenericParameter ( ) ) {
ret . add ( gtv . createAssumptions ( ) ) ;
}
2013-10-18 11:33:46 +00:00
return ret ;
}
2014-03-27 15:43:07 +00:00
2014-02-11 15:30:38 +00:00
@Override
public SyntaxTreeNode getParent ( ) {
2014-02-19 04:20:54 +00:00
return this ;
2014-02-11 15:30:38 +00:00
}
@Override
2015-04-22 19:40:22 +00:00
public Menge < SyntaxTreeNode > getChildren ( ) {
Menge < SyntaxTreeNode > ret = new Menge < SyntaxTreeNode > ( ) ;
2015-02-25 15:34:29 +00:00
//for(Field f : this.getFields()){
// ret.add(f);
//}
ret . addAll ( this . getFields ( ) ) ;
ret . addAll ( this . get_ParaList ( ) ) ;
2016-09-16 11:25:20 +00:00
ret . addAll ( this . getGenericParameter ( ) . getGTVList ( ) ) ;
2014-02-12 01:12:12 +00:00
return ret ;
2014-02-11 15:30:38 +00:00
}
2013-10-18 11:33:46 +00:00
2014-02-19 04:20:54 +00:00
@Override
public boolean equals ( Object obj ) {
if ( ! ( obj instanceof Class ) ) return false ;
Class cl = ( Class ) obj ;
if ( ! ( cl . getName ( ) . equals ( this . getName ( ) ) ) ) return false ;
return true ;
}
2014-03-12 14:27:26 +00:00
2014-07-16 08:33:34 +00:00
@Override
2016-09-16 11:25:20 +00:00
public GenericDeclarationList getGenericParameter ( ) {
return this . genericClassParameters ;
2014-07-16 08:33:34 +00:00
}
2014-03-12 14:27:26 +00:00
@Override
2016-04-07 12:53:29 +00:00
public String getDescription ( ) {
2014-03-12 14:27:26 +00:00
return " class " + this . getName ( ) ;
}
2014-06-25 15:30:31 +00:00
2014-05-07 11:01:14 +00:00
@Override
2014-06-25 15:30:31 +00:00
public void setGenericParameter ( GenericDeclarationList params ) {
2014-05-07 11:01:14 +00:00
this . genericClassParameters = params ;
}
2014-04-26 17:33:26 +00:00
2014-06-25 15:30:31 +00:00
@Override
2014-07-16 12:35:12 +00:00
public String getGenericVarDeclarationString ( String genericVarDeclaration ) {
if ( this . genericClassParameters ! = null ) {
return " , " + genericVarDeclaration ;
} else {
return " < " + genericVarDeclaration + " > " ;
}
}
@Override
public int getGenericVarDeclarationOffset ( ) {
2015-05-12 17:49:27 +00:00
// Falls Generische Parameterliste vorhanden, hier Wert der Liste zurückgegebn
2014-07-16 12:35:12 +00:00
if ( this . genericClassParameters ! = null ) {
2014-07-31 13:15:33 +00:00
return this . genericClassParameters . getEndOffset ( ) ;
2014-07-16 12:35:12 +00:00
} else {
return this . offset ;
}
2014-06-25 15:30:31 +00:00
}
2014-07-16 08:33:34 +00:00
2014-09-14 16:38:43 +00:00
/ * *
* Die Super Klasse dieser Klasse .
2015-05-12 17:49:27 +00:00
* @return null fà ¼ r Klasse Object
2014-09-14 16:38:43 +00:00
* /
2016-03-22 12:17:56 +00:00
public RefType getSuperClass ( ) {
2014-09-14 16:38:43 +00:00
return this . superClass ;
}
2015-02-24 16:06:14 +00:00
@Override
public boolean isClass ( ) {
return true ;
}
2015-08-27 14:36:19 +00:00
2016-10-28 16:31:42 +00:00
protected boolean isInterface ;
2015-08-27 14:36:19 +00:00
public boolean isInterface ( ) {
2016-10-28 16:31:42 +00:00
return isInterface ;
2015-08-27 14:36:19 +00:00
}
2015-10-22 18:40:33 +00:00
/ *
2015-10-20 13:58:39 +00:00
private Collection < ? extends ByteCodeResult > getGenericClasses ( ) {
2015-10-16 08:39:34 +00:00
Collection < ByteCodeResult > results = new Menge < > ( ) ;
2015-10-20 13:58:39 +00:00
for ( Field field : this . fielddecl ) {
Type type = field . getType ( ) ;
//Der Type des Feldes
if ( type instanceof RefType ) {
RefType refType = ( RefType ) type ;
if ( ! refType . getCombinedType ( null ) . equals ( refType . get_Name ( ) . replace ( " . " , " % " ) ) ) {
results . addAll ( generateGenericClass ( refType . getCombinedType ( null ) , new Class ( " java/util/Vector " , - 1 ) ) ) ;
}
}
if ( field instanceof Method ) {
Method method = ( Method ) field ;
ParameterList parameterList = method . getParameterList ( ) ;
//Die Typen der Methodenparameter
for ( FormalParameter parameter : parameterList ) {
Type parameterType = parameter . getType ( ) ;
if ( parameterType instanceof RefType ) {
RefType refType = ( RefType ) parameterType ;
if ( ! refType . getCombinedType ( null ) . equals ( refType . get_Name ( ) . replace ( " . " , " % " ) ) ) {
results . addAll ( generateGenericClass ( refType . getCombinedType ( null ) , new Class ( " java/util/Vector " , - 1 ) ) ) ;
}
}
}
}
}
return results ;
}
2015-10-22 18:40:33 +00:00
* /
2015-10-20 13:58:39 +00:00
2015-10-22 18:40:33 +00:00
/ *
2015-10-20 13:58:39 +00:00
private Menge < ByteCodeResult > generateGenericClass ( String name , Class superClass ) {
2015-10-23 09:48:35 +00:00
//TODO: bytecode -- Generics hinzuf<75> gen
2015-10-20 12:07:57 +00:00
//Type superClassType = superClass.getType();
2015-10-16 08:39:34 +00:00
2015-10-20 13:58:39 +00:00
//TODO: bytecode
//ClassGenerator genericClassGenerator = new ClassGenerator(name, superClassType, name + ".java", Constants.ACC_PUBLIC , new String[] { }, new TypeinferenceResultSet(null, null, null));
//TODO: bytecode -- Namen der neuen Klasse
Class generatedClass = new Class ( name , 0 ) ;
2015-10-16 13:15:30 +00:00
2015-10-20 13:58:39 +00:00
//TODO: bytecode -- alle Konstruktoren generieren
2015-10-16 13:15:30 +00:00
Block konstruktorBlock = new Block ( ) ;
2015-10-22 18:40:33 +00:00
konstruktorBlock . setType ( new de . dhbwstuttgart . syntaxtree . type . Void ( konstruktorBlock , 0 ) ) ;
2015-10-16 13:15:30 +00:00
konstruktorBlock . statements . add ( new SuperCall ( konstruktorBlock ) ) ;
2015-10-20 13:58:39 +00:00
Constructor standardKonstruktor = new Constructor ( Method . createEmptyMethod ( konstruktorBlock , name , superClass ) , superClass ) ;
standardKonstruktor . parserPostProcessing ( generatedClass ) ;
2015-10-16 13:15:30 +00:00
2015-10-20 13:58:39 +00:00
generatedClass . addField ( standardKonstruktor ) ;
return generatedClass . genByteCode ( new TypeinferenceResultSet ( generatedClass , new Menge < > ( ) , new ResultSet ( ) ) ) ;
}
2015-10-22 18:40:33 +00:00
* /
2013-10-18 11:33:46 +00:00
}
// ino.end