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 ;
2015-05-21 15:10:04 +00:00
2015-10-23 14:22:44 +00:00
import javax.lang.model.element.Modifier ;
2015-09-02 15:11:32 +00:00
import org.apache.commons.bcel6.generic.ClassGen ;
import org.apache.commons.bcel6.generic.ConstantPoolGen ;
import org.apache.commons.bcel6.generic.InstructionFactory ;
import org.apache.commons.bcel6.generic.InstructionHandle ;
import org.apache.commons.bcel6.generic.InstructionList ;
import org.apache.commons.bcel6.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.AClassOrInterface ;
import de.dhbwstuttgart.core.IItemWithOffset ;
2014-09-05 09:49:31 +00:00
import de.dhbwstuttgart.parser.JavaClassName ;
2015-10-16 13:15:30 +00:00
import de.dhbwstuttgart.syntaxtree.misc.DeclId ;
2014-09-02 08:33:54 +00:00
import de.dhbwstuttgart.syntaxtree.misc.UsedId ;
2014-09-05 09:49:31 +00:00
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 ;
2014-09-02 09:07:16 +00:00
import de.dhbwstuttgart.typeinference.unify.FC_TTO ;
import de.dhbwstuttgart.typeinference.unify.Unify ;
2015-05-27 13:57:15 +00:00
2015-09-02 15:11:32 +00:00
import org.apache.commons.bcel6.generic.* ;
import org.apache.commons.bcel6.classfile.* ;
import org.apache.commons.bcel6.* ;
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
2013-10-18 11:33:46 +00:00
// ino.class.Class.23010.declaration
2015-02-24 16:06:14 +00:00
public class Class extends GTVDeclarationContext implements AClassOrInterface , IItemWithOffset , Generic , GenericTypeInsertable
2013-10-18 11:33:46 +00:00
// ino.end
// ino.class.Class.23010.body
{
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 " ) ;
2014-02-12 01:12:12 +00:00
protected UsedId pkgName ;
protected Modifiers modifiers ;
protected String name ;
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 ( ) ;
2015-10-23 14:22:44 +00:00
short constants = Constants . ACC_PUBLIC ; //Per Definition ist jede Methode public
2015-11-06 15:42:22 +00:00
_cg = new ClassGenerator ( name , this . getSuperClass ( ) , 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
}
2015-09-02 15:11:32 +00:00
//Zuerst die Methoden und Felder abarbeiten:
for ( Method m : methods ) {
m . genByteCode ( _cg ) ;
}
InstructionList fieldInitializations = new InstructionList ( ) ;
for ( FieldDeclaration f : fieldDeclarations ) {
fieldInitializations . append ( f . genByteCode ( _cg ) ) ;
}
//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
}
2014-02-12 01:12:12 +00:00
2015-10-16 08:39:34 +00:00
private Menge < Type > superif = new Menge < Type > ( ) ;
2014-02-12 01:12:12 +00:00
public UsedId getPackageName ( )
{
return pkgName ;
}
public void setPackageName ( UsedId pkgName )
{
this . pkgName = pkgName ;
}
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 )
{
name = strName ;
}
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
2015-04-22 19:40:22 +00:00
public Menge < Type > getSuperInterfaces ( )
2014-02-12 01:12:12 +00:00
{
return superif ;
}
2014-09-14 16:38:43 +00:00
2014-09-18 14:26:02 +00:00
@Override
2015-04-22 19:40:22 +00:00
public void setSuperInterfaces ( Menge < Type > superif )
2014-02-12 01:12:12 +00:00
{
this . superif = superif ;
}
2013-10-18 11:33:46 +00:00
// ino.attribute.superclassid.23014.decldescription type=line
// private Status status;
// ino.end
// ino.attribute.superclassid.23014.declaration
public UsedId superclassid = ( SourceFile . READ_OBJECT_SUPERCLASSES_FROM_JRE ? UsedId . createFromQualifiedName ( " Object " , - 1 ) : null ) ;
// ino.end
// ino.attribute.class_block.23020.decldescription type=line
// private Class java;
// ino.end
// ino.attribute.class_block.23020.declaration
private Block class_block ;
// ino.end
// ino.attribute.paralist.23023.declaration
2015-04-22 19:40:22 +00:00
//private Menge<Type> paralist = new Menge<Type>(); // Parameterliste 'class xy<para1, para2,...>{}' wird gespeichert
2013-10-18 11:33:46 +00:00
// ino.end
// ino.attribute.parahash.23026.declaration
private Hashtable < String , String > parahash = new Hashtable < String , String > ( ) ; // parametrisierten Attrib. werden mit den Paramet.aus paralist verk.
// ino.end
// ino.attribute.isFirstLocalVarDecl.23029.declaration
public static boolean isFirstLocalVarDecl ; //Hilfsvariable fuer Offsets, hoth
// ino.end
2015-04-22 19:40:22 +00:00
//private Menge<GenericTypeVar> genericClassParameters=new Menge<GenericTypeVar>();
2013-10-18 11:33:46 +00:00
// ino.attribute.containedTypes.23032.decldescription type=line
// PL 05-07-30 eingefuegt. Vektor aller Typdeklarationen, die in der Klasse
2015-05-12 17:49:27 +00:00
// vorkommen. Wird in der Studienarbeit von Andreas Stadelmeier nur für Verifizierung der Tests eingesetzt.
2013-10-18 11:33:46 +00:00
// ino.end
// ino.attribute.containedTypes.23032.declaration
2015-04-22 19:40:22 +00:00
private Menge < Type > containedTypes = new Menge < Type > ( ) ;
2013-10-18 11:33:46 +00:00
// ino.end
// ino.attribute.usedIdsToCheck.23035.declaration
2015-04-22 19:40:22 +00:00
private Menge < UsedId > usedIdsToCheck = new Menge < UsedId > ( ) ;
2013-10-18 11:33:46 +00:00
// ino.end
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
// ino.attribute.parserlog.23038.declaration
2014-10-09 15:38:10 +00:00
//protected Logger parselog = Logger.getLogger("parser");
2013-10-18 11:33:46 +00:00
// ino.end
2014-10-09 15:38:10 +00:00
protected Logger typinferenzLog = Logger . getLogger ( Class . class . getName ( ) ) ;
2014-02-11 15:30:38 +00:00
private SyntaxTreeNode parent ;
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 ;
2014-09-18 14:26:02 +00:00
private Type superClass ;
2013-10-18 11:33:46 +00:00
// ino.method.Class.23041.definition
2014-07-16 12:35:12 +00:00
public Class ( String name , int offset )
2013-10-18 11:33:46 +00:00
// ino.end
// ino.method.Class.23041.body
{
2014-02-12 01:12:12 +00:00
this . name = name ;
2013-10-18 11:33:46 +00:00
if ( name . equals ( " java.lang.Object " ) ) {
superclassid = null ;
}
2014-07-16 12:35:12 +00:00
this . offset = offset ;
2015-10-23 12:13:17 +00:00
if ( ! name . equals ( " Object " ) & & ! name . equals ( " java.lang.Object " ) ) //Alle Klassen auà er Object erben von Object:
2015-10-23 09:48:35 +00:00
this . superClass = new Class ( " java.lang.Object " , - 1 ) . getType ( ) ;
2013-10-18 11:33:46 +00:00
}
// ino.end
2014-10-07 13:36:18 +00:00
/ * *
2015-05-12 17:49:27 +00:00
* Erstellt eine Klasse , welche nur fà ¼ r die Assumptions verwendet wird .
* Sie enthà ¤ lt keine unnà ¶ tigen Informationen , wie Offset oder ClassBody .
2014-10-07 13:36:18 +00:00
* @param name
* @param superClass
* @param modifiers
* @param supertypeGenPara - Eine Liste von Namen , welche die Generischen Parameter der Klasse darstellen .
* /
2015-11-17 16:35:17 +00:00
public Class ( String name , Type superClass , Modifiers modifiers , Menge < String > supertypeGenPara ) {
2014-10-07 13:36:18 +00:00
this ( name , superClass , modifiers , 0 ) ;
if ( supertypeGenPara = = null ) return ;
2015-04-22 19:40:22 +00:00
Menge < GenericTypeVar > gtvs = new Menge < > ( ) ;
2015-11-12 13:50:27 +00:00
for ( Object gname : supertypeGenPara ) {
if ( gname instanceof String ) {
GenericTypeVar newGTV = new GenericTypeVar ( ( String ) gname , this , 0 ) ;
gtvs . add ( newGTV ) ;
} else if ( gname instanceof GenericTypeVar ) {
gtvs . add ( ( GenericTypeVar ) gname ) ;
} else {
GenericTypeVar newGTV = new GenericTypeVar ( gname . toString ( ) , this , 0 ) ;
gtvs . add ( newGTV ) ;
throw new RuntimeException ( gname . toString ( ) ) ;
}
2014-10-07 13:36:18 +00:00
}
2015-02-03 14:58:04 +00:00
this . setGenericParameter ( new GenericDeclarationList ( gtvs , 0 ) ) ;
2014-10-07 13:36:18 +00:00
}
2015-10-30 11:29:43 +00:00
public Class ( String name , Type superClass , Modifiers mod , int offset ) {
2014-10-01 15:12:16 +00:00
this ( name , mod , offset ) ;
2015-10-23 14:22:44 +00:00
if ( superClass = = null ) this . superClass = new Class ( " java.lang.Object " , - 1 ) . getType ( ) ;
2015-04-08 19:23:28 +00:00
else this . superClass = superClass ;
2014-09-14 16:38:43 +00:00
}
2013-10-18 11:33:46 +00:00
// ino.method.Class.23044.definition
2014-07-16 12:35:12 +00:00
public Class ( String name , Modifiers mod , int offset )
2013-10-18 11:33:46 +00:00
// ino.end
// ino.method.Class.23044.body
{
2014-09-16 09:31:15 +00:00
this ( name , offset ) ;
2014-02-12 01:12:12 +00:00
this . modifiers = mod ;
2013-10-18 11:33:46 +00:00
}
// ino.end
2015-04-22 19:40:22 +00:00
public Class ( String name , Modifiers mod , ClassBody cb , Menge < Type > ct , Menge < UsedId > usedIdsToCheck ,
UsedId superclass , Menge < UsedId > superif , Menge < Type > paralist , int offset ) {
2014-09-18 14:26:02 +00:00
this ( name , mod , cb , ct , usedIdToRefType ( superclass ) , usedIdToRefType ( superif ) , paralist , offset ) ;
}
2015-04-22 19:40:22 +00:00
public Class ( String name , ClassBody cb , Menge < Type > ct ,
UsedId superclass , Menge < Type > superif , Menge < Type > paralist , int offset ) {
2014-09-18 14:26:02 +00:00
this ( name , null , cb , ct , usedIdToRefType ( superclass ) , superif , paralist , offset ) ;
}
public Class ( String name2 , Modifiers modifiers2 , ClassBody classBody ,
2015-04-22 19:40:22 +00:00
Menge < Type > containedTypes2 , UsedId usedId ,
Menge < Type > typeMenge , Menge < Type > paraMenge , int offset2 ) {
this ( name2 , modifiers2 , classBody , containedTypes2 , usedIdToRefType ( usedId ) , typeMenge , paraMenge , offset2 ) ;
2014-09-18 14:26:02 +00:00
}
public Class ( String name2 , Modifiers object , ClassBody classBody ,
2015-04-22 19:40:22 +00:00
Menge < Type > containedTypes2 , Menge < Type > typeMenge ,
Menge < Type > paraMenge , int offset2 ) {
this ( name2 , object , classBody , containedTypes2 , ( Type ) null , typeMenge , paraMenge , offset2 ) ;
2014-09-18 14:26:02 +00:00
}
2015-04-22 19:40:22 +00:00
private static Menge < Type > usedIdToRefType ( Menge < UsedId > superif2 ) {
Menge < Type > ret = new Menge < > ( ) ;
2014-09-18 14:26:02 +00:00
for ( UsedId id : superif2 ) ret . add ( usedIdToRefType ( id ) ) ;
return ret ;
}
private static Type usedIdToRefType ( UsedId superclass2 ) {
RefType ret = new RefType ( superclass2 . getSimpleName ( ) , null , superclass2 . getOffset ( ) ) ;
ret . set_ParaList ( superclass2 . get_ParaList ( ) ) ;
return ret ;
}
// ino.method.Class.23047.defdescription type=javadoc
2013-10-18 11:33:46 +00:00
/ * *
* Konstruktor , der die Angabe aller Parameter ermoeglicht .
* Zur Uebersichtlichkeit in der Grammatik .
* /
// ino.end
// ino.method.Class.23047.definition
2015-04-22 19:40:22 +00:00
public Class ( String name , Modifiers mod , ClassBody cb , Menge < Type > ct ,
Type superclass , Menge < Type > Menge , Menge < ? extends Type > paralist , int offset )
2013-10-18 11:33:46 +00:00
// ino.end
// ino.method.Class.23047.body
{
2014-09-16 09:31:15 +00:00
this ( name , offset ) ;
2014-02-12 01:12:12 +00:00
this . modifiers = mod ;
2013-10-18 11:33:46 +00:00
if ( cb ! = null ) set_ClassBody ( cb ) ;
if ( ct ! = null ) setContainedTypes ( ct ) ;
2014-09-16 09:31:15 +00:00
if ( superclass ! = null ) {
2014-09-18 14:26:02 +00:00
this . superClass = superclass ;
2014-09-16 09:31:15 +00:00
}
2015-04-22 19:40:22 +00:00
if ( Menge ! = null ) setSuperInterfaces ( Menge ) ;
2015-02-03 11:24:40 +00:00
if ( paralist ! = null & & ! paralist . isEmpty ( ) ) {
Type lastPara = paralist . lastElement ( ) ;
Integer lastItemOffset = lastPara . getOffset ( ) + lastPara . get_Name ( ) . length ( ) ;
2015-04-22 19:40:22 +00:00
this . setGenericParameter ( new GenericDeclarationList ( ( Menge < GenericTypeVar > ) paralist , lastItemOffset ) ) ;
2015-02-03 11:24:40 +00:00
/ *
2014-10-08 17:00:17 +00:00
//this.set_ParaList(paralist);
2015-04-22 19:40:22 +00:00
Menge < GenericTypeVar > gtvList = new Menge < > ( ) ;
2014-10-08 17:00:17 +00:00
int lastItemOffset = 0 ;
for ( Type paraT : paralist ) {
GenericTypeVar gtv = new GenericTypeVar ( paraT . get_Name ( ) , this , paraT . getOffset ( ) ) ;
gtvList . add ( gtv ) ;
lastItemOffset = paraT . getOffset ( ) + paraT . get_Name ( ) . length ( ) ;
}
this . genericClassParameters = new GenericDeclarationList ( gtvList , lastItemOffset ) ;
2015-02-03 11:24:40 +00:00
* /
2014-09-16 09:31:15 +00:00
}
2013-10-18 11:33:46 +00:00
if ( usedIdsToCheck ! = null ) this . usedIdsToCheck = usedIdsToCheck ;
// HOTI 10.5.06
// Object darf natuerlich nicht Object als Superklasse haben
// Sonst gibt es eine endlosaufloesung
if ( name . equals ( " java.lang.Object " ) ) {
superclassid = null ;
}
2014-09-16 09:31:15 +00:00
2013-10-18 11:33:46 +00:00
2014-10-09 15:38:10 +00:00
//parserlog.debug("Neue Klasse: " + name);
2013-10-18 11:33:46 +00:00
}
// ino.end
2014-09-18 14:26:02 +00:00
2015-04-22 19:40:22 +00:00
public Menge < Field > getFields ( )
2014-02-14 16:31:55 +00:00
{
return fielddecl ;
}
/ * *
* @author Andreas Stadelmeier , a10023
2015-05-12 17:49:27 +00:00
* FÃ ¼ gt der Klasse eine Feld hinzu .
* Prà ¼ ft dabei , ob es sich um einen Constructor handelt und wandelt diesen direkt um .
2014-02-14 16:31:55 +00:00
* @param feld
* /
public void addField ( Field i )
{
2014-02-19 16:32:43 +00:00
fielddecl . addElement ( i ) ;
2014-02-14 16:31:55 +00:00
}
2013-10-18 11:33:46 +00:00
// ino.method.getUsedIdsToCheck.23050.definition
2015-04-22 19:40:22 +00:00
public Menge < UsedId > getUsedIdsToCheck ( )
2013-10-18 11:33:46 +00:00
// ino.end
// ino.method.getUsedIdsToCheck.23050.body
{
return usedIdsToCheck ;
}
// ino.end
// ino.method.setContainedTypes.23053.definition
2015-04-22 19:40:22 +00:00
public void setContainedTypes ( Menge < Type > containedTypes )
2013-10-18 11:33:46 +00:00
// ino.end
// ino.method.setContainedTypes.23053.body
{
this . containedTypes = containedTypes ;
}
// ino.end
// ino.method.getContainedTypes.23056.definition
2015-04-22 19:40:22 +00:00
public Menge < Type > getContainedTypes ( )
2013-10-18 11:33:46 +00:00
// ino.end
// ino.method.getContainedTypes.23056.body
{
return containedTypes ;
}
// ino.end
2014-10-08 17:00:17 +00:00
/ *
2013-10-18 11:33:46 +00:00
// ino.method.complete_paralist.23062.definition
2015-04-22 19:40:22 +00:00
public Menge < Type > complete_paralist ( boolean ext )
2013-10-18 11:33:46 +00:00
// ino.end
// ino.method.complete_paralist.23062.body
{
2015-05-12 17:49:27 +00:00
//Diese Funktion vervollt�ndigt die Parameterliste f�r vererbte Klassen
2015-04-22 19:40:22 +00:00
Menge < Type > child = paralist ;
2013-10-18 11:33:46 +00:00
2015-04-22 19:40:22 +00:00
paralist = ( Menge < Type > ) superclassid . get_ParaList ( ) ;
2013-10-18 11:33:46 +00:00
for ( Enumeration < Type > e = child . elements ( ) ; e . hasMoreElements ( ) ; ) {
paralist . addElement ( e . nextElement ( ) ) ;
}
return this . paralist ;
}
// ino.end
2014-10-08 17:00:17 +00:00
* /
2013-10-18 11:33:46 +00:00
2014-03-12 15:32:50 +00:00
/ * *
2015-05-12 17:49:27 +00:00
* Generiert die ClassFile fà ¼ r diese Klasse .
2014-03-12 15:32:50 +00:00
* @param typeinferenceResult - Das ResultSet einer Typinferierung oder null , falls alle Typen eindeutig feststehen .
* @return
* @throws JVMCodeException
2014-09-02 16:49:19 +00:00
2013-10-18 11:33:46 +00:00
// ino.method.codegen.23071.definition
2014-03-12 15:32:50 +00:00
public ClassFile codegen ( ResultSet typeinferenceResult )
2013-10-18 11:33:46 +00:00
throws JVMCodeException
// ino.end
// ino.method.codegen.23071.body
{
ClassFile classfile = new ClassFile ( ) ;
String superClass ;
// Handling der Superklasse
if ( superclassid ! = null ) {
superClass = superclassid . get_codegen_UsedId ( ) ;
} else {
superClass = " java/lang/Object " ;
}
// Handling der Package
2014-03-12 15:32:50 +00:00
//String pkgName = "";
//if (sf.getPackageName() != null) {
// pkgName = sf.getPackageName().get_codegen_UsedId() + "/";
//}
2013-10-18 11:33:46 +00:00
2015-05-12 17:49:27 +00:00
//geändert von Andreas Stadelmeier: pkgName wird nicht mehr aus dem SourceFile ausgelesen:
2014-03-12 17:28:30 +00:00
String packageName = " " ;
if ( pkgName ! = null ) packageName = pkgName . get_Name_1Element ( ) ;
2014-09-02 16:49:19 +00:00
classfile . add_class ( getName ( ) , superClass , getAccessFlags ( ) ) ;
2013-10-18 11:33:46 +00:00
// Handling fuer Superinterfaces
classfile . addSuperInterfaces ( getSuperInterfaces ( ) ) ;
// Generics hinzufuegen - falls erforderlich
classfile . addGenerics ( this . paralist , superclassid , this . getSuperInterfaces ( ) ) ;
// Body der Classfile generieren
2014-02-14 16:31:55 +00:00
//if(body != null) {
this . codegen ( classfile , this . paralist ) ;
//}
2013-10-18 11:33:46 +00:00
// Ueberpruefung, ob Konstruktor generiert
// Falls nicht, default-Konstruktor erzeugen
if ( ! classfile . get_constructor_founded ( ) ) {
classfile . add_method ( " <init> " , " ()V " , null , null , null , ( short ) 0 , this . paralist , false ) ;
}
2014-03-12 15:32:50 +00:00
//classfile.codegen();
2013-10-18 11:33:46 +00:00
codegenlog . info ( " Compilierung erfolgreich abgeschlossen, " + getName ( ) + " .class erstellt. " ) ;
2014-03-12 15:32:50 +00:00
return classfile ;
2013-10-18 11:33:46 +00:00
}
2014-09-02 16:49:19 +00:00
* /
2014-09-05 09:49:31 +00:00
2013-10-18 11:33:46 +00:00
public void set_UsedId ( UsedId uid )
// ino.end
// ino.method.set_UsedId.23074.body
{
this . superclassid = uid ;
}
// ino.end
2014-02-14 16:31:55 +00:00
/ * *
2015-05-12 17:49:27 +00:00
* Setzt den ClassBody dieser Klasse . Wird zum Parsen benà ¶ tigt .
* Der ClassBody enthà ¤ lt sà ¤ mtliche Felder dieser Klasse .
* Mit dem Aufruf dieser Methode werden alle Felder des ClassBody in diese Class à ¼ bertragen .
* ( Nur einmal wà ¤ hrend des Parsens aufrufen ! )
2014-02-14 16:31:55 +00:00
* /
2013-10-18 11:33:46 +00:00
public void set_ClassBody ( ClassBody body )
{
2015-04-22 19:40:22 +00:00
Menge < Field > tempFields = body . getFields ( ) ;
2014-02-14 16:31:55 +00:00
for ( Field f : this . getFields ( ) ) {
2015-05-12 17:49:27 +00:00
if ( f instanceof Method ) { //Wenn es sich um eine Methode handelt ist eine zusätzliche Prüfung erfoderlich: (Ist es ein Konstruktor?)
2014-02-14 16:31:55 +00:00
Method m = ( Method ) f ;
/ *
* Ermitteln ob es sich bei der Methode um einen Konstruktor handelt :
* ( Parser kann nicht zwischen Methode und Konstruktor unterscheiden .
2015-05-12 17:49:27 +00:00
* Denn fà ¼ r einen Konstruktor gelten besondere Regeln :
2014-02-14 16:31:55 +00:00
* - Typ des Blocks eines Konstruktor ist void ( kein Return - Statement )
2015-05-12 17:49:27 +00:00
* - RÃ ¼ ckgabetyp der Methode / Konstruktors ist der Typ der Klasse
2014-02-14 16:31:55 +00:00
* - Ein Konstruktor kann nicht aufgerufen werden ( nur mit new )
* /
2015-05-12 17:49:27 +00:00
if ( m . get_Method_Name ( ) . equals ( " <init> " ) ) throw new TypeinferenceException ( " <init> ist kein gültiger Methodenname " , m ) ;
2014-02-14 16:31:55 +00:00
if ( ( m . get_Method_Name ( ) . equals ( this . getName ( ) ) ) ) {
2015-08-27 11:36:14 +00:00
Constructor constructor = new Constructor ( m , this ) ;
2015-05-12 17:49:27 +00:00
tempFields . add ( constructor ) ; //Den Konstruktor anstatt der Methode anfügen
2014-02-14 16:31:55 +00:00
} else {
2015-05-12 17:49:27 +00:00
//Handelt es sich um keinen Konstruktor, dann die Methode unverändert den Feldern hinzufügen:
2014-02-14 16:31:55 +00:00
tempFields . add ( m ) ;
}
} else {
2015-05-12 17:49:27 +00:00
tempFields . add ( f ) ; //Ansonsten das Feld anfügen...
2014-02-14 16:31:55 +00:00
}
}
this . fielddecl = tempFields ;
2013-10-18 11:33:46 +00:00
}
// ino.method.set_class_block.23080.definition
public void set_class_block ( Block block )
// ino.end
// ino.method.set_class_block.23080.body
{
this . class_block = block ;
}
// ino.end
2014-02-11 01:47:39 +00:00
2013-10-18 11:33:46 +00:00
// ino.method.get_Superclass_Name.23086.definition
2014-09-02 16:49:19 +00:00
public JavaClassName get_Superclass_Name ( )
2013-10-18 11:33:46 +00:00
// ino.end
// ino.method.get_Superclass_Name.23086.body
{
if ( superclassid ! = null )
return superclassid . getQualifiedName ( ) ;
else
return null ;
}
// ino.end
2014-02-14 16:31:55 +00:00
2013-10-18 11:33:46 +00:00
// ino.method.get_class_block.23092.definition
public Block get_class_block ( )
// ino.end
// ino.method.get_class_block.23092.body
{
return class_block ;
}
// ino.end
// ino.method.does_Class_extend.23095.definition
public boolean does_Class_extend ( )
// ino.end
// ino.method.does_Class_extend.23095.body
{
if ( superclassid = = null )
return false ;
else
return true ;
}
// ino.end
2014-10-08 17:00:17 +00:00
/ *
2013-10-18 11:33:46 +00:00
// ino.method.set_ParaList.23098.definition
2015-04-22 19:40:22 +00:00
public void set_ParaList ( Menge < Type > para )
2013-10-18 11:33:46 +00:00
// ino.end
// ino.method.set_ParaList.23098.body
{
this . paralist = para ;
}
// ino.end
2014-10-08 17:00:17 +00:00
* /
2013-10-18 11:33:46 +00:00
// ino.method.get_ParaList.23101.definition
2015-04-22 19:40:22 +00:00
public Menge < ? 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>();
2014-10-08 17:00:17 +00:00
return this . getGenericParameter ( ) ;
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
2014-02-11 01:47:39 +00:00
public ConstraintsSet typeReconstruction ( FC_TTO supportData , 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
2014-10-09 15:38:10 +00:00
typinferenzLog . debug ( " Erstellte FiniteClosure: " + supportData , Section . TYPEINFERENCE ) ;
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 ) ;
2014-02-12 21:10:33 +00:00
/ *
2013-10-18 11:33:46 +00:00
//Generiere Liste mit Expressions, welche zur Initialisierung von Feldern verwendet werden.
2015-04-22 19:40:22 +00:00
Menge < Expr > fieldInitializers = new Menge < Expr > ( ) ;
2014-02-12 01:12:12 +00:00
for ( FieldDeclaration field : body . getFieldInitializations ( ) ) {
2013-10-18 11:33:46 +00:00
Assign fieldAssign = new Assign ( 0 , 0 ) ;
Expr expr1 = new LocalOrFieldVar ( field . getName ( ) , 0 ) ;
Expr expr2 = field . getWert ( ) ;
fieldAssign . set_Expr ( expr1 , expr2 ) ;
fieldInitializers . add ( fieldAssign ) ;
}
2014-02-12 21:10:33 +00:00
* /
2013-10-18 11:33:46 +00:00
2014-02-12 21:10:33 +00:00
//ConstraintsSet oderConstraints = this.TYPE(this.getMethodList(), fieldInitializers, assumptions);
2015-06-17 10:03:54 +00:00
this . superClass = this . superClass . TYPE ( assumptions , this ) ;
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 ( ) ) ;
2015-05-12 17:49:27 +00:00
//this.getMethodList(); //Diese Funktion muss zuerst ausgeführt werden.
//Assumption für this, also die aktuelle Klasse: (ist nicht mehr nötig, da jedes AssumptionSet einer Klasse (dem namen einer Klasse) zugewiesen ist.
2013-10-18 11:33:46 +00:00
//CLocalVarTypeAssumption thisAssumption = new CLocalVarTypeAssumption(this.name, name, 0, 0, name, "this", new RefType(name,0), 0, 0, null);
//assumptions.setThisV(thisAssumption);
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
//Eine Assumption für den Standardkonstruktor:
// (Ein Standardkonstruktor wird immer angefügt, da es momentan keine statischen Klassen gibt)
//auskommentiert, da der Standardkonstruktor beim Parser-Postprocessing angefügt wird.
//if(assumptions.getMethodAssumptions(this.getName(), "<init>").size()==0){ //Falls kein Konstruktor für diese Klasse definiert wurde:
2015-04-22 19:40:22 +00:00
// assumptions.addMethodAssumption(new RefType(this.getName(),0), "<init>", new RefType(this.getName(),0), new Menge<CParaTypeAssumption>());
2014-02-19 04:20:54 +00:00
//}
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
2014-02-10 03:25:14 +00:00
// ino.method.toString.23125.defdescription type=javadoc
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
* /
// ino.end
// ino.method.toString.23125.definition
public String toString ( )
// ino.end
// ino.method.toString.23125.body
{
//return superclassid.toString() + body.toString();
//geaendert PL 07-07-28
2014-02-14 16:31:55 +00:00
return name ;
2013-10-18 11:33:46 +00:00
}
// ino.end
// ino.method.wandleRefTypeAttributes2GenericAttributes.23128.defdescription type=javadoc
/ * *
2015-05-12 17:49:27 +00:00
* Alle Methoden der Klassen à ¼ berprà ¼ fen , ob sie als
2013-10-18 11:33:46 +00:00
* RefType deklarierte Attribute haben , die aber GenericTypeVars sind
* und ggf . ersetzen
*
* Bsp . :
* bei public E elementAt ( i ) { . . . } wird E vorerst als RefType erkannt
*
* /
// ino.end
// ino.method.wandleRefTypeAttributes2GenericAttributes.23128.definition
public void wandleRefTypeAttributes2GenericAttributes ( )
// ino.end
// ino.method.wandleRefTypeAttributes2GenericAttributes.23128.body
{
2014-03-27 15:43:07 +00:00
for ( Field f : this . getFields ( ) ) {
2014-07-09 14:04:33 +00:00
//f.wandleRefTypeAttributes2GenericAttributes(paralist);
2014-03-27 15:43:07 +00:00
}
2013-10-18 11:33:46 +00:00
}
/ * *
* HOTI
* Liefert bei Klassen die fullyQualified angegeben wurden
* nur den schlussendlichen Bezeichner
2015-04-22 19:40:22 +00:00
* p . ex . de . dhbwstuttgart . typeinference . Menge = > Menge
2013-10-18 11:33:46 +00:00
* @return
* /
// ino.end
// ino.method.getSimpleName.23140.definition
public String getSimpleName ( )
// ino.end
// ino.method.getSimpleName.23140.body
{
2014-09-02 16:49:19 +00:00
return UsedId . createFromQualifiedName ( getName ( ) . toString ( ) , - 1 ) . getSimpleName ( ) ;
2013-10-18 11:33:46 +00:00
}
// ino.end
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
* /
2014-02-09 15:07:31 +00:00
public String printJavaCode ( TypeinferenceResultSet reconstructionResult ) {
2013-10-18 11:33:46 +00:00
JavaCodeResult ret = new JavaCodeResult ( " class " ) ;
JavaCodeResult classBodyCode = new JavaCodeResult ( ) ;
if ( this . modifiers ! = null ) classBodyCode . attach ( this . modifiers . printJavaCode ( reconstructionResult . getUnifiedConstraints ( ) ) ) . attach ( " " ) ;
classBodyCode . attach ( this . name + " extends " ) . attach ( superclassid . printJavaCode ( reconstructionResult . getUnifiedConstraints ( ) ) ) . attach ( " \ n " ) ;
2014-02-14 16:31:55 +00:00
JavaCodeResult bodyString = new JavaCodeResult ( " { \ n " ) ;
for ( Field field : this . fielddecl ) bodyString . attach ( field . printJavaCode ( reconstructionResult . getUnifiedConstraints ( ) ) ) . attach ( " \ n " ) ;
bodyString . attach ( " } \ n " ) ;
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 ( ) ;
ret . attach ( tph . printJavaCode ( reconstructionResult . getUnifiedConstraints ( ) ) ) ;
if ( it . hasNext ( ) ) ret . attach ( " , " ) ;
}
ret . attach ( " > " ) ;
}
String stringReturn = ret . attach ( classBodyCode ) . toString ( ) ;
return stringReturn ;
}
/ * *
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-02-11 15:30:38 +00:00
@Override
public void parserPostProcessing ( SyntaxTreeNode parent ) {
2014-03-18 19:18:57 +00:00
//Wenn keine Superklasse, dann erbt die Klasse zwangsweise von Object:
if ( superclassid = = null | | superclassid . get_Name ( ) . size ( ) < 1 ) {
int superclassidOffset = superclassid = = null ? 0 : superclassid . getOffset ( ) ;
superclassid = new UsedId ( " Object " , superclassidOffset ) ;
}
2014-02-19 16:32:43 +00:00
//Alle Methoden auf Konstruktoren durchsuchen und diese umwandeln:
2015-04-22 19:40:22 +00:00
Menge < Field > tempFields = new Menge < Field > ( ) ;
2014-02-19 16:32:43 +00:00
for ( Field f : this . getFields ( ) ) {
2015-08-26 12:48:51 +00:00
if ( f instanceof Method & & ! ( f instanceof Constructor ) ) { //Der Check, ob f ein Konstruktor ist eigentlich obsolet, da der Parser keinen Konstruktor generiert
2014-02-19 16:32:43 +00:00
Method method = ( Method ) f ;
2015-02-25 15:34:29 +00:00
if ( method . get_Method_Name ( ) . equals ( this . getName ( ) . toString ( ) ) ) {
2015-08-26 12:48:51 +00:00
tempFields . add ( new Constructor ( method , this ) ) ;
2014-02-19 16:32:43 +00:00
} else {
tempFields . add ( f ) ;
}
} else {
tempFields . add ( f ) ;
}
}
this . fielddecl = tempFields ;
2015-05-12 17:49:27 +00:00
//Prüfen ob ein Konstruktor vorhanden ist:
2014-02-19 04:20:54 +00:00
boolean constructorVorhanden = false ;
for ( Field f : this . getFields ( ) ) {
if ( f instanceof Constructor ) {
constructorVorhanden = true ;
break ;
}
}
2015-05-12 17:49:27 +00:00
if ( ! constructorVorhanden ) { //Falls kein Konstruktor vorhanden ist, muss noch der Standardkonstruktor angefügt werden:
2015-06-16 15:44:27 +00:00
Block konstruktorBlock = new Block ( ) ;
konstruktorBlock . statements . add ( new SuperCall ( konstruktorBlock ) ) ;
2015-08-27 11:36:14 +00:00
Constructor standardKonstruktor = new Constructor ( Method . createEmptyMethod ( konstruktorBlock , this . getName ( ) . toString ( ) , this ) , this ) ;
2015-06-17 09:08:50 +00:00
//Constructor standardKonstruktor = new Constructor(Method.createEmptyMethod(this.getName().toString(), this));
2015-06-16 15:44:27 +00:00
2014-02-19 04:20:54 +00:00
this . addField ( standardKonstruktor ) ;
}
2014-03-27 15:43:07 +00:00
2015-04-22 19:40:22 +00:00
if ( this . genericClassParameters = = null ) this . setGenericParameter ( new GenericDeclarationList ( new Menge < GenericTypeVar > ( ) , 0 ) ) ;
2014-10-08 17:00:17 +00:00
/ * //Nicht mehr notwendig, Generische Klassenparameter werden nun immer direkt in die genericClassParameters gespeichert.
2014-09-09 09:15:10 +00:00
for ( Type t : this . get_ParaList ( ) ) {
if ( t instanceof GenericTypeVar ) this . genericClassParameters . add ( ( GenericTypeVar ) t ) ;
else this . genericClassParameters . add ( new GenericTypeVar ( t . get_Name ( ) , this , - 1 ) ) ;
}
2014-10-08 17:00:17 +00:00
* /
2015-02-25 15:34:29 +00:00
/ *
2014-09-16 09:31:15 +00:00
for ( Type t : this . get_ParaList ( ) ) {
t . parserPostProcessing ( this ) ;
}
2015-02-25 15:34:29 +00:00
* /
2014-09-10 21:32:36 +00:00
/ *
2014-09-09 09:15:10 +00:00
for ( GenericTypeVar gtv : this . getGenericParameter ( ) ) {
gtv . setParentClass ( this ) ; ;
}
2014-09-10 21:32:36 +00:00
* /
2014-04-14 16:05:24 +00:00
//TODO: Umwandlung zu RefTypes funktioniert noch nicht richtig. (siehe LambdaTest2)
2014-03-27 15:43:07 +00:00
//Als RefType geparste Generische Variablen umwandeln:
this . wandleRefTypeAttributes2GenericAttributes ( ) ;
2015-02-25 15:34:29 +00:00
//Erst am Schluss, nachdem Methoden zu Konstruktoren umgewandelt wurden:
super . parserPostProcessing ( parent ) ;
2014-02-11 15:30:38 +00:00
}
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 ( ) ) ;
2014-09-10 21:32:36 +00:00
ret . addAll ( this . getGenericParameter ( ) ) ;
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
2015-04-22 19:40:22 +00:00
public Menge < GenericTypeVar > getGenericParameter ( ) {
if ( this . genericClassParameters = = null ) return new Menge < GenericTypeVar > ( ) ;
return this . genericClassParameters . getMenge ( ) ;
2014-07-16 08:33:34 +00:00
}
2014-03-12 14:27:26 +00:00
@Override
public String getDescription ( ) {
return " class " + this . getName ( ) ;
}
2014-04-16 14:02:16 +00:00
@Override
public int getVariableLength ( ) {
// TODO Auto-generated method stub
return 0 ;
}
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
* /
2014-09-18 14:26:02 +00:00
public Type 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
public boolean isInterface ( ) {
return false ;
}
2015-10-16 08:39:34 +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