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 org.apache.commons.bcel6.generic.BranchInstruction;
import  org.apache.commons.bcel6.generic.ClassGen;
import org.apache.commons.bcel6.generic.GOTO;
import org.apache.commons.bcel6.generic.IF_ICMPGE;
import org.apache.commons.bcel6.generic.InstructionHandle;
import org.apache.commons.bcel6.generic.InstructionList;
import org.apache.commons.bcel6.generic.NOP;

import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.myexception.SCExcept;
import de.dhbwstuttgart.myexception.SCStatementException;
import de.dhbwstuttgart.syntaxtree.Class;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
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.RefType;
import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.syntaxtree.type.Void;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.JavaCodeResult;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
import de.dhbwstuttgart.typeinference.unify.Unify;





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(Menge<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh)
    throws SCStatementException
    {
    	
    }
    
    public String toString()
    {
        return "FOR ";
    }
    
    public void wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<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;
		
	}

	@Override
	public ConstraintsSet TYPEStmt(TypeAssumptions assumptions) {
		//TODO: TYPEStmt
		ConstraintsSet ret = new ConstraintsSet();
		this.setType(TypePlaceholder.fresh(this));
		
		ret.add(body_Loop_block.TYPEStmt(assumptions));
		
		return ret;
	}

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

	@Override
	public JavaCodeResult printJavaCode(ResultSet resultSet) {
		// TODO printJavaCode
		return new JavaCodeResult();
	}

	@Override
	public Menge<SyntaxTreeNode> getChildren() {
		Menge<SyntaxTreeNode> ret = new Menge<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;
	}

	@Override
	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
		/*
		 0: iconst_0
         1: istore_1
         2: iload_1
         3: bipush        10
         5: if_icmpge     14
         8: iinc          1, 1
        11: goto          2
        14: return
		 */
		
		InstructionList il = new InstructionList();
		
		il.append(head_Initializer.genByteCode(_cg, rs));
		
		InstructionHandle ih = il.append(head_Condition.genByteCode(_cg, rs));
		
		BranchInstruction branch = new IF_ICMPGE(null);
		il.append(branch);
		
		il.append(body_Loop_block.genByteCode(_cg, rs));
		
		il.append(head_Loop_expr.genByteCode(_cg, rs));
		
		il.append(new GOTO(ih));
		
		branch.setTarget(il.append(new NOP()));

		return il;
	}
}