JavaPatternMatching/src/mycompiler/myclass/Constructor.java

package mycompiler.myclass;

import java.util.Vector;

import mycompiler.SyntaxTreeNode;
import mycompiler.mybytecode.ClassFile;
import mycompiler.myexception.JVMCodeException;
import mycompiler.mymodifier.Modifiers;
import mycompiler.mystatement.Block;
import mycompiler.mytype.GenericTypeVar;
import mycompiler.mytype.RefType;
import mycompiler.mytype.Type;
import mycompiler.mytypereconstruction.replacementlistener.CReplaceTypeEvent;
import typinferenz.ConstraintsSet;
import typinferenz.JavaCodeResult;
import typinferenz.ResultSet;
import typinferenz.SingleConstraint;
import typinferenz.assumptions.ConstructorAssumption;
import typinferenz.assumptions.MethodAssumption;
import typinferenz.assumptions.TypeAssumptions;
import typinferenz.exceptions.TypinferenzException;

public class Constructor extends Method {
	private Method methode;

	/**
	 * Parser kann nicht zwischen einem Konstruktor und einer Methode unterscheiden.
	 * Diese Klasse beherbegt den als Methode geparsten Konstruktor und wandelt sein verhalten zu dem eines Konstruktors ab.
	 */
	public Constructor(Method methode){
		super(methode.getOffset());
		this.methode = methode;
		this.setDeclIdVector(methode.getDeclIdVector());
		this.methode.setType(this.methode.getParentClass().getType());
	}


	@Override
	public void setGenericMethodParameters(
			Vector<GenericTypeVar> genericMethodParameters) {
		 
		this.methode.setGenericMethodParameters(genericMethodParameters);
	}

	@Override
	public Vector<GenericTypeVar> getGenericMethodParameters() {
		 
		return this.methode.getGenericMethodParameters();
	}

	@Override
	public void sc_init_parameterlist(boolean ext) {
		 
		this.methode.sc_init_parameterlist(ext);
	}

	@Override
	public String getTypeName() {
		 
		return this.getType().getName();
	}

	@Override
	public Block get_Block() {
		 
		return this.methode.get_Block();
	}



	@Override
	public void set_Block(Block blo) {
		 
		this.methode.set_Block(blo);
	}

	@Override
	public void set_Modifiers(Modifiers modif) {
		 
		this.methode.set_Modifiers(modif);
	}

	@Override
	public void set_ExceptionList(ExceptionList exlist) {
		 
		this.methode.set_ExceptionList(exlist);
	}

	@Override
	public void setParameterList(ParameterList paralist) {
		 
		this.methode.setParameterList(paralist);
	}

	@Override
	public ParameterList getParameterList() {
		 
		return this.methode.getParameterList();
	}

	@Override
	public int getParameterCount() {
		 
		return this.methode.getParameterCount();
	}

	@Override
	public ExceptionList get_ExceptionList() {
		 
		return this.methode.get_ExceptionList();
	}

	@Override
	public int getOverloadedID() {
		 
		return this.methode.getOverloadedID();
	}

	@Override
	public void setOverloadedID(int overloadedID) {
		 
		this.methode.setOverloadedID(overloadedID);
	}

	@Override
	public String get_codegen_Param_Type(Vector paralist) {
		 
		return this.methode.get_codegen_Param_Type(paralist);
	}

	@Override
	public String get_Method_Name() {
		 
		return this.methode.get_Method_Name();
	}

	@Override
	public Vector get_Type_Paralist() {
		 
		return this.methode.get_Type_Paralist();
	}

	@Override
	public void codegen(ClassFile classfile, Vector paralist)
			throws JVMCodeException {
		 
		this.methode.codegen(classfile, paralist);
	}

	@Override
	public int getLineNumber() {
		 
		return this.methode.getLineNumber();
	}

	@Override
	public void setLineNumber(int lineNumber) {
		 
		this.methode.setLineNumber(lineNumber);
	}

	@Override
	public int getOffset() {
		 
		return this.methode.getOffset();
	}

	@Override
	public int getVariableLength() {
		 
		return this.methode.getVariableLength();
	}

	@Override
	public void setOffset(int Offset) {
		 
		this.methode.setOffset(Offset);
	}

	@Override
	public void replaceType(CReplaceTypeEvent e) {
		 
		this.methode.replaceType(e);
	}

	@Override
	public int getTypeLineNumber() {
		 
		return this.methode.getTypeLineNumber();
	}

	@Override
	public String toString() {
		 
		return this.methode.toString();
	}

	@Override
	public void setAbstract(boolean b) {
		 
		this.methode.setAbstract(b);
	}

	@Override
	public boolean isAbstract() {
		 
		return this.methode.isAbstract();
	}

	@Override
	public void wandleRefTypeAttributes2GenericAttributes(Vector<Type> paralist) {
		 
		this.methode.wandleRefTypeAttributes2GenericAttributes(paralist);
	}

	@Override
	public void set_Method_Name(String string) {
		 
		this.methode.set_Method_Name(string);
	}

	public ConstraintsSet TYPE(TypeAssumptions ass) {
		ConstraintsSet ret = new ConstraintsSet();
		
		ret.add(this.methode.get_Block().TYPEStmt(ass));
		return ret;
	}

	@Override
	public String getTypeInformation() {
		 
		return this.methode.getTypeInformation();
	}

	@Override
	public JavaCodeResult printJavaCode(ResultSet resultSet) {
		 
		return this.methode.printJavaCode(resultSet);
	}

	@Override
	public TypeAssumptions createTypeAssumptions(Class classmember) {
		Class parentClass = this.getParentClass();
		TypeAssumptions ret = new TypeAssumptions();
		ret.addAssumption(new ConstructorAssumption(this, parentClass));
		return ret;
	}

	@Override
	public SyntaxTreeNode getParent(){
		return this.methode.getParent();
	}
	
	@Override
	public void parserPostProcessing(SyntaxTreeNode parent) {
		 
		this.methode.parserPostProcessing(parent);
	}

	@Override
	public Vector<SyntaxTreeNode> getChildren() {
		 
		return this.methode.getChildren();
	}

	@Override
	public void setType(Type t) {
		throw new TypinferenzException("Einem Konstruktor kann kein Typ zugewiesen werden");
		//this.methode.setType(t);
	}

	@Override
	public Type getType() {
		return this.methode.getType();
	}


	@Override
	public boolean equals(Object obj) {
		return this.methode.equals(obj);
	}


	@Override
	public void set_DeclId(DeclId did) {
		this.methode.set_DeclId(did);
	}


	@Override
	public Vector<DeclId> get_Name() {
		return this.methode.get_Name();
	}


	@Override
	public Vector<DeclId> getDeclIdVector() {
		return this.methode.getDeclIdVector();
	}


	@Override
	public void setDeclIdVector(Vector<DeclId> vDeclId) {
		this.methode.setDeclIdVector(vDeclId);
	}


	@Override
	public String getIdentifier() {
		return this.methode.getIdentifier();
	}


	@Override
	public String getDescription() {
		return this.methode.getDescription();
	}


	@Override
	public Class getParentClass() {
		return this.methode.getParentClass();
	}
	
	
}

/*
// ino.class.Constructor.23267.declaration 
public class Constructor_Backup extends Method
// ino.end
// ino.class.Constructor.23267.body
{
    // ino.method.Constructor.23271.definition 
    public Constructor_Backup()
    // ino.end
    // ino.method.Constructor.23271.body 
    {
        this.setParameterList(null);
        // #JB# 04.06.2005
        // ###########################################################
        DeclId decl = new DeclId();
        decl.set_Name("<init>");
        this.set_DeclId(decl);
        // ###########################################################
    }
    // ino.end
    
    
    
    // ino.method.get_codegen_Param_Type.23274.definition 
    public String get_codegen_Param_Type(Vector paralist)
    // ino.end
    // ino.method.get_codegen_Param_Type.23274.body 
    {
        String ret = new String();
        if(this.getParameterList() == null)
        {
            ret += "()";
        }
        else
        {
            ret += this.getParameterList().get_codegen_ParameterList(paralist);
        }
        ret += "V";
        return ret;
    }
    // ino.end
    
    
    
    // ino.method.codegen.23277.definition 
    public void codegen(ClassFile classfile, Vector paralist)
    throws JVMCodeException
    // ino.end
    // ino.method.codegen.23277.body 
    {
        classfile.set_constructor_founded(true);
        classfile.add_method("<init>", this.get_codegen_Param_Type(paralist), this.getParameterList(), null, get_Block(), declid.firstElement().get_access_flags(), paralist, false);
    }
    // ino.end
    
}
*/