CGBinaryOperation.cs

Go to the documentation of this file.

using TypeSystem.Operations;
using TypeSystem;
using ErrorManagement;
using AST;
using Tools;
using System.Collections.Generic;
using CodeGeneration.ExceptionManagement;
namespace CodeGeneration.Operations {
    class CGBinaryOperationsInfo {
        internal struct Info {
            internal TypeExpression typeExpression;
            internal bool allTypeExpressions;
            internal bool box;
            internal bool unbox;
        };
        internal Info[] info = new Info[2];
        // type of the second operand of an arithmetic expression
        public bool firstTime;  // indicates whether it is the last expressión, that is after this expression it is necessary to generate the end Label
        public int operandOrdinal = 0;

        public int size = 2;

        public bool isEnd = false;

        public CGBinaryOperationsInfo(TypeExpression t1, TypeExpression t2) {
            this.info[0].allTypeExpressions = false;
            this.info[0].typeExpression = t1;
            this.info[0].box = false;
            this.info[0].unbox = false;
            this.info[1].allTypeExpressions = false;
            this.info[1].typeExpression = t2;
            this.info[1].box = false;
            this.info[1].unbox = false;

        }

        public CGBinaryOperationsInfo(CGBinaryOperationsInfo c) {
            this.size = c.size;
            this.firstTime = c.firstTime;
            this.operandOrdinal = c.operandOrdinal;
            this.info = new Info[c.size];
            this.isEnd = c.isEnd;
            for ( int i = 0; i < c.size; i++ ) {
                this.info[i].typeExpression = c.info[i].typeExpression;
                this.info[i].allTypeExpressions = c.info[i].allTypeExpressions;
                this.info[i].box = c.info[i].box;
                this.info[i].unbox = c.info[i].unbox;
            }
        }
        public CGBinaryOperationsInfo(TypeExpression typeExpression1, TypeExpression typeExpression2,
            //string notThisTypeLabel, 
                                        int operandOrdinal, bool firstTime, bool allTypeExpressions1,
                                        bool allTypeExpressions2)
            : this(typeExpression1, typeExpression2) {
            this.operandOrdinal = operandOrdinal;

            this.info[0].allTypeExpressions = allTypeExpressions1;
            this.info[1].allTypeExpressions = allTypeExpressions2;
            this.info[0].box = false;
            this.info[0].unbox = false;
            this.info[1].box = false;
            this.info[1].unbox = false;

        }

        public CGBinaryOperationsInfo Clone() {
            return new CGBinaryOperationsInfo(this);
        }
        //public CGBinaryOperationsInfo NewLabel(string label) {
        //    return new CGBinaryOperationsInfo(this.typeExpression1, this.typeExpression2, label, this.operandOrdinal, this.firstTime, this.allTypeExpressions1, this.allTypeExpressions2);
        //}


        public CGBinaryOperationsInfo NotFirstTime() {
            CGBinaryOperationsInfo cl = this.Clone();
            cl.firstTime = false;
            return cl;

        }

    }
    internal abstract class CGBinaryOperation<T> : TypeSystemOperation where T : ILCodeGenerator {


        protected BinaryExpression node;


        protected string endOperationLabel;

        protected string errorLabel;

        protected VisitorILCodeGeneration<T> visitor;
        protected T codeGenerator;
        protected int indent;
        protected object obj;
        private string finalizeOperationLabel;
        public CGBinaryOperation(VisitorILCodeGeneration<T> visitor, object obj, int indent, BinaryExpression node) {
            this.codeGenerator = visitor.codeGenerator;
            this.indent = indent;
            this.visitor = visitor;
            this.obj = obj;
            this.node = node;
            this.errorLabel = string.Format("{0}_ERROR_OPERATION", this.codeGenerator.NewLabel);
            this.endOperationLabel = string.Format("{0}_END_OPERATION", this.codeGenerator.NewLabel);
            this.finalizeOperationLabel = string.Format("{0}_FINALIZE_OPERATION", this.codeGenerator.NewLabel);
            this.node.FirstOperand.Accept(this.visitor, this.obj);

        }

        public virtual CGBinaryOperationsInfo GetFirstInfo(TypeExpression t1, object arg) {
            CGBinaryOperationsInfo ret;
            if ( arg == null ) {// it's the first call of the operation 
                ret = new CGBinaryOperationsInfo(t1, node.SecondOperand.ILTypeExpression);
                ret.isEnd = true;
                ret.firstTime = true;
            } else
                ret = ( (CGBinaryOperationsInfo)arg ).Clone();

            return ret;
        }


        public override object Exec(TypeVariable t, object arg) {

            TypeExpression te;
            CGBinaryOperationsInfo info = GetFirstInfo(t, arg);

            if ( t.HasFreshVariable() ) {
                te = GenerateAll(info, this.node);
                info.info[info.operandOrdinal].allTypeExpressions = true;

            } else
                te = t.Substitution;

            info.info[info.operandOrdinal].typeExpression = te;
            info.info[info.operandOrdinal].unbox = true;
            return info.info[0].typeExpression.AcceptOperation(this, info);
        }


        public override object Exec(TypeExpression t1, object arg) {
            CGBinaryOperationsInfo cga = GetFirstInfo(t1, arg);

            TypeExpression t2 = cga.info[1].typeExpression;
            // we check if the second operand is an UnionType
            if ( TypeExpression.Is<UnionType>(t2) ) {
                cga.operandOrdinal = 1;
                node.SecondOperand.Accept(this.visitor, this.obj);
                ExecUnionSecondOperand(t1, TypeExpression.As<UnionType>(t2), cga);
            } else if ( TypeExpression.Is<TypeVariable>(t2) ) {
                cga.operandOrdinal = 1;
                Exec(TypeExpression.As<TypeVariable>(t2), cga);
            } else {

                TypeExpression result = GenerateOperands(cga, node);

                GenerateOperator(cga, result, node);
                MakeBoxIfNeeded(result, node);
                this.codeGenerator.br(this.indent, this.endOperationLabel);


            }
            // else
            if ( cga.isEnd )
                EndOperation();
            return null;
        }

        public override object Exec(UnionType ut, object arg) {

            CGBinaryOperationsInfo ai = GetFirstInfo(ut, arg);
            ai.isEnd = false;
            UnionType utn = ut;
            if ( !ai.info[0].allTypeExpressions && ut.HasFreshVariable() ) {
                utn = GenerateAll(ai, this.node);
                ai.info[0].allTypeExpressions = true;
            }
            string next = null;

            for ( int i = 0; i < utn.TypeSet.Count; i++ ) {
                TypeExpression ti = ut.TypeSet[i];
                CGBinaryOperationsInfo cgi = new CGBinaryOperationsInfo(ai);
                cgi.info[cgi.operandOrdinal].typeExpression = ti;

                if ( TypeExpression.Is<TypeVariable>(ti) )
                    ti.AcceptOperation(this, cgi);
                else if ( TypeExpression.Is<UnionType>(ti) ) {
                    cgi.firstTime = false;
                    this.indent++;
                    ti.AcceptOperation(this, cgi);
                    this.indent--;

                } else {
                    cgi.info[0].unbox = true;
                    cgi.info[0].box = false;
                    next = string.Format("{0}_1Op_not_a_{1}", this.codeGenerator.NewLabel, ti.ILType());
                    this.codeGenerator.Comment(this.indent, string.Format("1Op_case: [{0}]", ti.ILType()));
                    this.codeGenerator.dup(this.indent);
                    this.codeGenerator.isinst(this.indent, ti);
                    this.codeGenerator.brfalse(this.indent, i == utn.Count - 1 ? this.errorLabel : next);
                    ti.AcceptOperation(this, cgi);
                    this.codeGenerator.WriteLabel(this.indent, next);

                }

            }
            if ( ai.firstTime )
                EndOperation();
            return null;
        }
        protected virtual void EndOperation() {
            this.codeGenerator.br(this.indent, this.endOperationLabel);
            this.codeGenerator.WriteLabel(this.indent, this.errorLabel);
            this.codeGenerator.WriteThrowException(this.indent, new WrongDynamicTypeExceptionManager());
            this.codeGenerator.AddExceptionCode(new WrongDynamicTypeExceptionManager());
            this.codeGenerator.WriteLabel(this.indent, this.endOperationLabel);
        }

        protected virtual void ExecUnionSecondOperand(TypeExpression t1, UnionType unionType, CGBinaryOperationsInfo cg) {
            CGBinaryOperationsInfo cga = cg.Clone();
            cga.isEnd = false;
            UnionType utn = unionType;
            if ( !cga.info[1].allTypeExpressions && utn.HasFreshVariable() ) {
                utn = GenerateAll(cga, this.node);
                cga.info[1].allTypeExpressions = true;
            }
            string next = null;

            for ( int i = 0; i < utn.TypeSet.Count; i++ ) {
                TypeExpression ti = utn.TypeSet[i];
                CGBinaryOperationsInfo cgi = cga.Clone();
                cgi.info[cgi.operandOrdinal].typeExpression = ti;
                cgi.info[0].typeExpression = t1;
                next = string.Format("{0}_2Op_not_a_{1}", this.codeGenerator.NewLabel, ti.ILType());
                this.codeGenerator.Comment(this.indent, string.Format("2Op_case: [{0}]", ti.ILType()));
                if ( TypeExpression.Is<TypeVariable>(ti) )
                    ti.AcceptOperation(this, cgi);
                else if ( TypeExpression.Is<UnionType>(ti) ) {
                    cgi.firstTime = false;

                    this.codeGenerator.pop(this.indent);
                    this.indent++;
                    ti.AcceptOperation(this, cgi);
                    this.indent--;

                } else {
                    //this.node.SecondOperand.Accept(this.visitor, this.obj);
                    cgi.info[1].unbox = true;
                    cgi.info[1].box = false;
                    this.codeGenerator.dup(this.indent);
                    this.codeGenerator.isinst(this.indent, ti);
                    this.codeGenerator.brfalse(this.indent, i == utn.Count - 1 ? this.errorLabel : next);
                    this.codeGenerator.pop(this.indent);
                    t1.AcceptOperation(this, cgi);
                }
                this.codeGenerator.WriteLabel(this.indent, next);
            }

        }

 


        abstract protected void GenerateOperator(CGBinaryOperationsInfo cga, TypeExpression result, BinaryExpression node);
        abstract protected UnionType GenerateAll(CGBinaryOperationsInfo ai, BinaryExpression b);

        virtual protected TypeExpression GenerateOperands(CGBinaryOperationsInfo cga, BinaryExpression node) {
            TypeExpression majorType = MajorType(cga.info[0].typeExpression, cga.info[1].typeExpression);
            if (cga.info[0].unbox)
                MakeUnboxIfNeeded(cga.info[0].typeExpression);
            CGConversion(cga.info[0], majorType);
            

            this.node.SecondOperand.Accept(this.visitor, this.obj);
            if ( cga.info[1].unbox )
                MakeUnboxIfNeeded(cga.info[1].typeExpression);
            
            CGConversion(cga.info[1], majorType);

            return majorType;
        }

        virtual protected void CGConversion(CGBinaryOperationsInfo.Info info, TypeExpression majorType) {
            info.typeExpression.AcceptOperation(new CGConvertToOperation<ILCodeGenerator>(majorType, this.codeGenerator, this.indent), null);
        }

        virtual protected TypeExpression MajorType(TypeExpression typeExpression1, TypeExpression typeExpression2) {
            return (TypeExpression)typeExpression1.AcceptOperation(new MajorTypeOperation(typeExpression2), null);
        }
        virtual protected void MakeBoxIfNeeded(TypeExpression t, BinaryExpression node) {

            if ( TypeExpression.Is<UnionType>(node.ExpressionType) )
                this.codeGenerator.BoxIfNeeded(this.indent, t);
        
        }
        virtual protected void MakeUnboxIfNeeded(TypeExpression t) {

            if ( t.IsValueType() )
                this.codeGenerator.UnboxAny(this.indent, t);
        }     
        public override object ReportError(TypeExpression tE) {
            ErrorManager.Instance.NotifyError(new CodeGenerationError("No se ha definido la operación solicitada"));
            return null;
        }
    }
}