JavaPatternMatching/src/de/dhbwstuttgart/syntaxtree/statement/ForStmt.java

package de.dhbwstuttgart.syntaxtree.statement;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Vector;

import mycompiler.mybytecode.ClassFile;
import mycompiler.mybytecode.CodeAttribute;
import mycompiler.mybytecode.JVMCode;
import mycompiler.myexception.CTypeReconstructionException;
import mycompiler.myexception.JVMCodeException;
import mycompiler.myexception.SCExcept;
import mycompiler.myexception.SCStatementException;
import mycompiler.mytypereconstruction.CSupportData;
import mycompiler.mytypereconstruction.CTriple;
import mycompiler.mytypereconstruction.replacementlistener.CReplaceTypeEvent;
import mycompiler.mytypereconstruction.set.CSubstitutionSet;
import mycompiler.mytypereconstruction.set.CTripleSet;
import mycompiler.mytypereconstruction.set.CTypeAssumptionSet;
import mycompiler.mytypereconstruction.typeassumption.CTypeAssumption;
import mycompiler.mytypereconstruction.unify.Unify;

import org.apache.log4j.Logger;

import de.dhbwstuttgart.core.SyntaxTreeNode;
import de.dhbwstuttgart.syntaxtree.Class;
import de.dhbwstuttgart.syntaxtree.operator.LogOp;
import de.dhbwstuttgart.syntaxtree.operator.Operator;
import de.dhbwstuttgart.syntaxtree.operator.RelOp;
import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar;
import de.dhbwstuttgart.syntaxtree.type.Pair;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import sun.reflect.generics.reflectiveObjects.NotImplementedException;






public class ForStmt extends Statement
{
    
    private Expr head_Initializer_1;
	private Expr head_Condition_1;
	private Expr head_Loop_expr_1;
	private Expr head_Initializer;
	private Expr head_Condition;
	private Expr head_Loop_expr;
	private Statement body_Loop_block;

	public ForStmt(int offset, int variableLength)
    {
        super(offset,variableLength);
    }
    
    void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh)
    throws SCStatementException
    {
    	
    }
    
    public void codegen(ClassFile classfile, CodeAttribute code, Vector paralist)
    throws JVMCodeException
    {

    }
    
    
    public String toString()
    {
        return "FOR ";
    }
    
    public void wandleRefTypeAttributes2GenericAttributes(Vector<Type> paralist, Vector<GenericTypeVar> genericMethodParameters) 
    {
        if(body_Loop_block!=null){
            body_Loop_block.wandleRefTypeAttributes2GenericAttributes(paralist,genericMethodParameters);
        }
        
    }

	public void set_head_Initializer(Expr expr) {
		head_Initializer = expr;
		
	}

	public void set_head_Condition(Expr expr) {
		head_Condition = expr;
		
	}

	public void set_head_Loop_expr(Expr expr) {
		head_Loop_expr = expr;
		
	}

	public void set_body_Loop_block(Statement statement) {
		body_Loop_block = statement;
		
	}
	
	public boolean addOffsetsToStatement(CTypeAssumption localAssumption, String NameVariable, boolean isMemberVariable)
    {
    	head_Initializer_1.addOffsetsToStatement(localAssumption,NameVariable,isMemberVariable);
    	body_Loop_block.addOffsetsToStatement(localAssumption,NameVariable,isMemberVariable);
        return true;
    }

	@Override
	public ConstraintsSet TYPEStmt(TypeAssumptions assumptions) {
		// TODO Auto-generated method stub
		return null;
	}
	
	public void replaceType(CReplaceTypeEvent e) {
		// TODO Auto-generated method stub
		throw new NotImplementedException();
	}

	public int getTypeLineNumber() {
		throw new NotImplementedException();
	}

	@Override
public JavaCodeResult printJavaCode(ResultSet resultSet) {
		// TODO Auto-generated method stub
		throw new NotImplementedException();
	}

	@Override
	public Vector<SyntaxTreeNode> getChildren() {
		Vector<SyntaxTreeNode> ret = new Vector<SyntaxTreeNode>();
		if(this.body_Loop_block!=null)ret.add(this.body_Loop_block);
		if(this.head_Condition!=null)ret.add(this.head_Condition);
		if(this.head_Condition_1!=null)ret.add(this.head_Condition_1);
		if(this.head_Initializer!=null)ret.add(this.head_Initializer);
		if(this.head_Initializer_1!=null)ret.add(this.head_Initializer_1);
		if(this.head_Loop_expr!=null)ret.add(this.head_Loop_expr);
		if(this.head_Loop_expr_1!=null)ret.add(this.head_Loop_expr_1);
		//throw new NotImplementedException();
		return ret;
	}
}