// ino.module.Assign.8622.package 
package mycompiler.mystatement;
// ino.end
// ino.module.Assign.8622.import 
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.myclass.Class;
import mycompiler.myexception.CTypeReconstructionException;
import mycompiler.myexception.JVMCodeException;
import mycompiler.myexception.SCExcept;
import mycompiler.myexception.SCStatementException;
import mycompiler.mytype.GenericTypeVar;
import mycompiler.mytype.Pair;
import mycompiler.mytype.Type;
import mycompiler.mytype.TypePlaceholder;
import mycompiler.mytype.Void;
import mycompiler.mytypereconstruction.CMultiplyTuple;
import mycompiler.mytypereconstruction.CSupportData;
import mycompiler.mytypereconstruction.CTriple;
import mycompiler.mytypereconstruction.set.CMultiplyTupleSet;
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;
// ino.end
import typinferenz.JavaCodeResult;
import typinferenz.SingleConstraint;
import typinferenz.ConstraintsSet;
import typinferenz.FreshTypeVariable;
import typinferenz.ResultSet;
import typinferenz.TypeAssumptions;




// ino.class.Assign.24926.declaration 
public class Assign extends Expr
// ino.end
// ino.class.Assign.24926.body
{
    // ino.method.Assign.24930.definition 
    public Assign(int offset,int variableLength)
    // ino.end
    // ino.method.Assign.24930.body 
    {
        super(offset,variableLength);
    }
    // ino.end


    // ino.attribute.expr1.24933.declaration 
    public Expr expr1;
    // ino.end
    // ino.attribute.expr2.24936.declaration 
    public Expr expr2;
    // ino.end

    // ino.attribute.parserlog.24939.decldescription type=javadoc
    /**
     * Logger log4j
     */
    // ino.end
    // ino.attribute.parserlog.24939.declaration 
    protected static Logger parserlog = Logger.getLogger("parser");
    // ino.end
    
    
    // ino.method.set_Expr.24942.definition 
    public void set_Expr(Expr expr1,Expr expr2)
    // ino.end
    // ino.method.set_Expr.24942.body 
    {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }
    // ino.end
    
    
    
    // ino.method.sc_check.24945.definition 
    public void sc_check(Vector<Class> classname, Hashtable ch, Hashtable<String, String> bh, boolean ext, Hashtable parach, Hashtable<String, Hashtable> parabh)
    throws SCStatementException
    // ino.end
    // ino.method.sc_check.24945.body 
    {
        SCStatementException except = null;
        try
        {
            expr1.sc_check(classname, ch, bh, ext, parach, parabh);
        }
        catch(SCStatementException ex)
        {
            except=ex;
        }
        try
        {
            expr2.sc_check(classname, ch, bh, ext, parach, parabh);
        }
        catch(SCStatementException ex)
        {
            if(except==null)
            {
                except=ex;
            }
            else
            {
                Vector<SCExcept>   v = ex.get_exlist();
                SCExcept hilf;
                for(Enumeration<SCExcept> el=v.elements() ; el.hasMoreElements() ; )
                {
                    hilf = el.nextElement();
                    except.addException(hilf);
                }
            }
        }
        expr1.getTypeName();
        expr2.getTypeName();
        parserlog.debug( "SC -> Expression linker Typ: " + expr1.getTypeName());
        parserlog.debug( "SC -> Expression rechter Typ: " + expr1.getTypeName());
        if( expr1.getTypeName() == null || expr2.getTypeName() == null )
        {
            SCExcept ex = new SCExcept();
            ex.set_error("Eine Variable ist ohne gesetzten Typ.");
            ex.set_statement("Assign");
            if( except == null )
            {
                except=new SCStatementException();
            }
            except.addException(ex);
        }
        else
        {
            if(expr2.getTypeName().equals("__NULL__"))
            {
                if(ext)
                {
                    parserlog.debug("Assign setzt Variable auf null");
                }
            }
            else
            {
                if(!expr1.getTypeName().equals(expr2.getTypeName()))
                {
                    // Linker Typ = Rechter Typ
                    parserlog.debug( "SC -> Linker Typ = Rechter Typ");
                    if(expr1.getTypeName().equals("int")&&expr2.getTypeName().equals("char"))
                    {
                        parserlog.info("ACHTUNG! Hier wird einem int ein char zugewiesen.");
                        if(expr1.get_UsedId()==null)
                        {
                            parserlog.error("UsedId geht net");
                        }
                        parserlog.debug("int "+expr1.get_UsedId().get_Name().toString()+" = char "+expr2.get_UsedId().get_Name().toString());
                    }
                    else
                    {
                        if(ext)
                        {
                            parserlog.error("Typfehler: -->Assign.sc_check() ");
                        }
                        SCExcept neu=new SCExcept();
                        neu.set_error("Typfehler");
                        neu.set_statement("Assign: "+expr1.getTypeName()+" = "+expr2.getTypeName());
                        if(except == null)
                        {
                            except=new SCStatementException();
                        }
                        except.addException(neu);
                    }
                }
            }
        }
        if(except!= null)
        {
            throw except;
        } 
    }
    // ino.end
    
    
    
    // ino.method.get_Name.24948.definition 
    public String get_Name()
    // ino.end
    // ino.method.get_Name.24948.body 
    {
        return null;
    }
    // ino.end
    
    
    
    // ino.method.codegen.24951.definition 
    public void codegen(ClassFile classfile, CodeAttribute code, Vector paralist)
    throws JVMCodeException
    // ino.end
    // ino.method.codegen.24951.body 
    {
        // AutoBoxing-Feature: Literale koennen nur als Objekt zugewiesen werden
        if (expr2 instanceof Literal) ((Literal)expr2).setPrimitiveFlag(false);
        
        
        if(expr1 instanceof LocalOrFieldVar)
        {
            LocalOrFieldVar local = (LocalOrFieldVar)expr1;
            Vector name_vector = local.get_Name_Vector();
            Vector type_vector = local.get_Type_Vector();
            String local_name = null;
            String class_name = null;
            String type = null;
            for(int i=0; i < name_vector.size()-1; i++)
            {
                local_name = (String)name_vector.elementAt(i);
                type = JVMCode.get_codegen_Type((String)type_vector.elementAt(i), paralist);
                int index = code.get_indexOf_Var(local_name);
                if(index != -1)
                {
                    // LocalVar
                    try
                    {
                        String local_type = code.get_TypeOf_Var(local_name).getName();
                        code.add_code(JVMCode.nload_n(local_type, index));
                    }
                    catch(JVMCodeException e)
                    {
                        // out of nload_n
                        String local_type = code.get_TypeOf_Var(local_name).getName();
                        code.add_code(JVMCode.nload(local_type));
                        code.add_code_byte((byte)index);
                    }
                }
                else
                {
                    // FieldVar
                    code.add_code(JVMCode.aload_0);
                    code.add_code(JVMCode.getfield);
                    code.add_code_short(classfile.add_field_ref(local_name, class_name, type));
                }
                class_name = (String)type_vector.elementAt(i);
            }
            expr2.codegen(classfile, code, paralist);
            local_name = (String)name_vector.lastElement();
            int index = code.get_indexOf_Var(local_name);
            if(index != -1)
            {
                // LocalVar
                try
                {
                    String local_type = code.get_TypeOf_Var(local_name).getName();
                    code.add_code(JVMCode.nstore_n(local_type, index));
                }
                catch(JVMCodeException e)
                {
                    // out of nstore_n
                    String local_type = code.get_TypeOf_Var(local_name).getName();
                    code.add_code(JVMCode.nstore(local_type));
                    code.add_code_byte((byte)index);
                }
            }
            else
            {
                // FieldVar
                code.add_code(JVMCode.putfield);
                code.add_code_short(classfile.add_field_ref(local_name, class_name, JVMCode.get_codegen_Type(expr2.getTypeName(), paralist)));
            }
        }
        else if(expr1 instanceof InstVar)
        {
            InstVar instvar = (InstVar)expr1;
            String instvar_name = instvar.get_codegen_UsedId();
            code.add_code(JVMCode.aload_0);
            expr2.codegen(classfile, code, paralist);
            code.add_code(JVMCode.putfield);
            code.add_code_short(classfile.add_field_ref(instvar_name, null, null));
        }
        else throw new  JVMCodeException("JVMCodeException: Assign: void test codegen(ClassFile classfile, Code_attribute code)");
    }
    // ino.end

    /**
     * @author AI10023 - Andreas Stadelmeier
     */
	@Override
	public ConstraintsSet TYPEExpr(TypeAssumptions assumptions) {
		ConstraintsSet ret = new ConstraintsSet();
		ret.add(expr1.TYPEExpr(assumptions));
		ret.add(expr2.TYPEExpr(assumptions));
		//this.setTypeVariable( TypePlaceholder.fresh(this));
		this.setTypeVariable(TypePlaceholder.fresh(this));
		ret.add(new SingleConstraint(expr2.getTypeVariable(), expr1.getTypeVariable())); //expr1.type < expr2.type
		ret.add(new SingleConstraint(expr1.getTypeVariable(), this.getTypeVariable())); 
		return ret;
	}
	
	/**
	 * Spezifikation:
	 * 	TYPEStmt( Ass, stmt ) =
	 * 	let (stmt : rty, ConS) = TYPEExpr( Ass, stmt )
	 * 	in (stmt : Void, ConS)
	 */
	@Override
	public ConstraintsSet TYPEStmt(TypeAssumptions assumptions){
		ConstraintsSet ret = this.TYPEExpr(assumptions); //TypeExpr aufrufen
		this.setTypeVariable(new Void(0)); //Typ des Statments auf Void setzen.
		return ret;
	}

    // ino.method.TRExp.24954.defdescription type=javadoc
    /**
     * Implementierung des Algorithmus 5.30 von Martin Pl�micke
     * <br/>Author: J�rg B�uerle
     * @param sigma
     * @param V
     * @param supportData
     * @return
     */
    // ino.end
    // ino.method.TRExp.24954.definition 
    public CTripleSet TRExp(CSubstitutionSet sigma, CTypeAssumptionSet V, CSupportData supportData)
    // ino.end
    // ino.method.TRExp.24954.body 
    {
        CTripleSet returnSet = new CTripleSet();
        
        Vector<Expr> epressions = new Vector<Expr>();
        epressions.addElement(this.expr1);
        epressions.addElement(this.expr2);
        // --------------------------
        // TRTuple rufen:
        // --------------------------
        CMultiplyTupleSet tupleSet = this.TRTuple(new CMultiplyTuple(sigma, new Vector<Type>(), V), epressions, supportData);
        Iterator<CMultiplyTuple> tupleIt = tupleSet.getIterator();
        Vector<CTypeReconstructionException> exceptions=new Vector<CTypeReconstructionException>();
        while(tupleIt.hasNext()){
            CMultiplyTuple tuple = tupleIt.next();
            if(tuple.getResultTypes().size()!=2){
                throw new CTypeReconstructionException("Assign.TRExp(): Ung�ltige Anzahl von ReturnTypes",this);
            }
            // --------------------------
            // Die beiden ReturnTypes unifizieren:
            // --------------------------
            Type ty1 = tuple.getResultTypes().elementAt(0);
            Type ty2 = tuple.getResultTypes().elementAt(1);
            Vector<Vector<Pair>> unifierPossibilities = Unify.unify(ty2, ty1, supportData.getFiniteClosure());
            // --------------------------
            // Subset bauen:
            // --------------------------
            CTripleSet subSet = new CTripleSet();
            // --------------------------
            // Wenn Unifier vorhanden, dann anwenden:
            // --------------------------
            if(unifierPossibilities.size()!=0){
                // --------------------------
                // Alle m�glichen Unifier auf V anwenden:
                // --------------------------
                for(int k=0; k<unifierPossibilities.size(); k++){
                    CSubstitutionSet unifier = new CSubstitutionSet(unifierPossibilities.elementAt(k));
                    // --------------------------
                    // Typannahmen bauen:
                    // --------------------------
                    CTypeAssumptionSet V_substituted = tuple.getAssumptionSet().deepCopy();
                    V_substituted.sub(unifier);
                    // --------------------------
                    // Substitutionen bauen:
                    // --------------------------
                    CSubstitutionSet substitutionSet = tuple.getSubstitutions().deepCopy();
                    substitutionSet.applyUnifier(unifier);
                    substitutionSet.unite(unifier);
    
            //PL geaendert 05-08-23 applyThisSubstitutionSet eingefuegt
                    // --------------------------
                    // R�ckgabetyp bauen:
                    // --------------------------
                    // if(ty1 instanceof TypePlaceholder){
    //                         Iterator<CSubstitution> pairIt = unifier.getIterator();
    //                         while(pairIt.hasNext()){
    //                             CSubstitution pair = pairIt.next();
    //                             if(pair.getTypeVar().getName().equals(ty1.getName())){
    //                                 ty1 = pair.getType();
    //                                 break;
    //                             }
    //                         }
    //                     }
                    // --------------------------
                    CTriple subTriple = new CTriple(substitutionSet, substitutionSet.applyThisSubstitutionSet(ty1), V_substituted);
    
                    // --------------------------
                    // Triple zu R�ckgabemenge hinzuf�gen
                    // --------------------------
                    subSet.addElement(subTriple);
                }
            }
            // --------------------------
            // Ansonsten Fehlermeldung:
            // --------------------------
            else {
            		//MUSS AUSSERHALB DER ITERATOR WHILE-SRHLEIFE PL 07-08-11 STEHEN
            		//throw new CTypeReconstructionException("Assign.TRExp(): Typen "+ty1+" und "+ty2+" lassen sich nicht unifizieren.",this);
            		exceptions.add(new CTypeReconstructionException("Assign.TRExp(): Typen "+ty1+" und "+ty2+" lassen sich nicht unifizieren.",this));

            } 
            returnSet.unite(subSet);
        }
    //CTripleSet returnSet2 = super.unifyAndRegisterType(returnSet, supportData);
    CTripleSet returnSet2 = super.registerType(returnSet, supportData);
    
    //eingefuegt PL 07-08-11
    //Anfang
    if(returnSet.getCardinality()==0){
    		if (exceptions.size()==1) {
    			throw exceptions.elementAt(0);
    		}
    		else {
    			throw new CTypeReconstructionException("Assign.TRExp(): Es gibt kein Typpaar das sich unifizieren laesst.",this);
    		}

    }
    //Ende
    
    return returnSet2;
    }
    // ino.end



    // ino.method.TRStatement.24957.defdescription type=javadoc
    /**
     * Implementierung des Algorithmus 5.25 von Martin Pl�micke
     * <br>Author: J�rg B�uerle
     * @param sigma
     * @param V
     * @param supportData
     * @return
     */
    // ino.end
    // ino.method.TRStatement.24957.definition 
    public CTripleSet TRStatement(CSubstitutionSet sigma, CTypeAssumptionSet V, CSupportData supportData)
    // ino.end
    // ino.method.TRStatement.24957.body 
    {
        CTripleSet resultSet = this.TRExp(sigma, V, supportData);
        resultSet = resultSet.deepCopy();
        Iterator<CTriple> it = resultSet.getIterator();
        while(it.hasNext()){
            it.next().setResultType(new Void(getOffset()));
        }
        return resultSet;
    }
    // ino.end
    
     // ino.method.toString.24960.defdescription type=javadoc
     /**
      * <br/>Author: Martin Pl�micke
      * @return
      */
     // ino.end
    // ino.method.toString.24960.definition 
    public String toString()
    // ino.end
    // ino.method.toString.24960.body 
    {
    	if(getTypeVariable() == null)return "(" + expr1.toString() + " = " + expr2.toString() + ")";
        return getTypeVariable().toString() + "(" + expr1.toString() + " = " + expr2.toString() + ")";
    }
    // ino.end


    // ino.method.wandleRefTypeAttributes2GenericAttributes.24963.definition 
    public void wandleRefTypeAttributes2GenericAttributes(Vector<Type> paralist, Vector<GenericTypeVar> genericMethodParameters)
    // ino.end
    // ino.method.wandleRefTypeAttributes2GenericAttributes.24963.body 
    {
    }
    // ino.end
    
    public void addOffsetsToExpression(CTypeAssumption localAssumption,String NameVariable,boolean isMemberVariable)
    {
    	expr1.addOffsetsToExpression(localAssumption,NameVariable,isMemberVariable);
        expr2.addOffsetsToExpression(localAssumption,NameVariable,isMemberVariable); 
    }

    @Override
    public String getTypeInformation(){
        return "(" + expr1.getTypeInformation() + " = " + expr2.getTypeInformation() + ") : "+this.getTypeVariable();
    }

    @Override
    public JavaCodeResult printJavaCode(ResultSet resultSet){
    	JavaCodeResult ret = new JavaCodeResult().attach(this.expr1.printJavaCode(resultSet) ).attach( " = " ).attach( this.expr2.printJavaCode(resultSet));
    	return ret;
    }

}
// ino.end