OoasTools

/**

  *

  *                      OOAS Compiler (Deprecated)

  *

  * Copyright 2015, Institute for Software Technology, Graz University of

  * Technology. Portions are copyright 2015 by the AIT Austrian Institute

  * of Technology. All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * Please notice that this version of the OOAS compiler is considered de-

  * precated. Only the Java version is maintained.

  *

  * Contributors:

  *               Willibald Krenn (TU Graz/AIT)

  *               Stefan Tiran (TU Graz/AIT)

  */

/*

 * Limited C# code generation capabilities. Used for ooaObjectInstantiateVisitor to

 * detect how many objects the system creates.

*/

using System;

using System.Collections.Generic;

using System.Text;

using TUG.Mogentes.Codegen;

namespace TUG.Mogentes.Codegen.CSharp

{

    public sealed class CSharpIdentifier

    {

        public static string GetIdentifierString(string anIdentifier)

        {

            return String.Format("_{0}", anIdentifier);

        }

    }

    public sealed class CSharpType : OoaTypeVisitor

    {

        private OoaCodeEmitter m_emitter = new OoaCodeEmitter();

        private string GetIdentifierString(string anIdentifier)

        {

            return CSharpIdentifier.GetIdentifierString(anIdentifier);

        }

        public override void visit(CharType charType)

        {

            m_emitter.Append("int"); // ToDo: map to char?

        }

        public override void visit(IntType intType)

        {

            m_emitter.Append("int");

        }

        public override void visit(BoolType boolType)

        {

            m_emitter.Append("bool");

        }

        public override void visit(FloatType floatType)

        {

            m_emitter.Append("double");

        }

        public override void visit(EnumType enumType)

        {

            m_emitter.Append(GetIdentifierString(enumType.identifier.tokenText));

        }

        public override void visit(ListType listType)

        {

            m_emitter.Append("TUG.Mogentes.Codegen.CSharp.UlyssesList<object>");

            //listType.innerType.Accept(this);

            //m_emitter.Append(">");

        }

        public override void visit(MapType mapType)

        {

            //System.Collections.Generic.Dictionary

            m_emitter.Append("UlyssesDictionary<object,object>");

            //mapType.fromType.Accept(this);

            //m_emitter.Append(",");

            //mapType.toType.Accept(this);

            //m_emitter.Append(">");

        }

        public override void visit(QrType qrType)

        {

            m_emitter.Append("UlyssesQualitativeValue");

        }

        public override void visit(TupleType tupleType)

        {

            // we map a tuple to a struct

            m_emitter.Append(GetIdentifierString(tupleType.identifier.tokenText));

        }

        public override void visit(FunctionType functionType)

        {

            throw new NotImplementedException();

        }

        public override void visit(OoActionSystemType ooActionSystemType)

        {

            m_emitter.Append(GetIdentifierString(ooActionSystemType.identifier.tokenText));

        }

        public override void visit(OpaqueType opaqueType)

        {

            throw new NotImplementedException();

        }

        public override string ToString()

        {

            return m_emitter.ToString();

        }

    }

    public sealed class CSharpExpression : OoaExpressionVisitor

    {

        private OoaCodeEmitter m_emitter = new OoaCodeEmitter();

        private StringBuilder m_helpers;

        private static List<ObjectConstructor> m_constructors = new List<ObjectConstructor>();

        private string GetCSharpType(UlyssesType aType)

        {

            CSharpType sharptype = new CSharpType();

            aType.Accept(sharptype);

            return sharptype.ToString();

        }

        private string GetIdentifierString(string anIdentifier)

        {

            return CSharpIdentifier.GetIdentifierString(anIdentifier);

        }

        public static List<ObjectConstructor> constructors { get { return m_constructors; } }

        // following calls must not happen

        public override void visit(UnresolvedIdentifierExpression unresolvedIdentifierExpression)

        {

            System.Diagnostics.Debug.Assert(false);

        }

        public override void visit(CallExpression callExpression)

        {

            System.Diagnostics.Debug.Assert(false);

        }

        // we need to map all other things to C# constructs

        private string OperatorString(Expression expression)

        {

            switch (expression.kind)

            {

                case ExpressionKind.abs:    // T_ABS:

                case ExpressionKind.card:   // T_CARD:

                case ExpressionKind.dom:    // T_DOM:

                case ExpressionKind.range:  // T_RNG:

                case ExpressionKind.merge:  // T_MERGE:

                case ExpressionKind.len:    // T_LEN:

                case ExpressionKind.elems:  // T_ELEMS:

                case ExpressionKind.head:   // T_HEAD:

                case ExpressionKind.tail:   // T_TAIL:

                case ExpressionKind.conc:   // T_CONC:

                case ExpressionKind.inds:   // T_INDS:

                case ExpressionKind.dinter: // T_DINTER:

                case ExpressionKind.dunion: // T_DUNION:

                case ExpressionKind.domresby:   // T_DOMRESBY:

                case ExpressionKind.domresto:   // T_DOMRESTO:

                case ExpressionKind.rngresby:   // T_RNGRESBY:

                case ExpressionKind.rngresto:   // T_RNGRESTO:

                case ExpressionKind.inter:  // T_INTER:

                case ExpressionKind.union:  // T_UNION:

                case ExpressionKind.diff:   // T_DIFF:

                case ExpressionKind.munion: // T_MUNION:

                case ExpressionKind.seqmod_mapoverride: // T_SEQMOD_MAPOVERRIDE:

                case ExpressionKind.subset:

                case ExpressionKind.elemin:

                case ExpressionKind.notelemin:

                case ExpressionKind.implies:    // T_IMPLIES:

                case ExpressionKind.biimplies:  // T_BIIMPLIES:

                case ExpressionKind.Primed:

                    throw new NotImplementedException();

                case ExpressionKind.div:    // T_DIV:

                    return "/";

                case ExpressionKind.idiv:   // T_IDIV:

                    return "/";

                case ExpressionKind.mod:    // T_MOD:

                    return "%";

                case ExpressionKind.prod:   // T_PROD:

                    return "*";

                case ExpressionKind.sum:    // T_SUM:

                    return "+";

                case ExpressionKind.minus:  // T_MINUS:

                    return "-";

                case ExpressionKind.less:

                    return "<";

                case ExpressionKind.lessequal:

                    return "<=";

                case ExpressionKind.greater:

                    return ">";

                case ExpressionKind.greaterequal:

                    return ">=";

                case ExpressionKind.equal:

                    return "==";

                case ExpressionKind.notequal:

                    return "!=";

                case ExpressionKind.and:    // T_AND:

                    return "&&";

                case ExpressionKind.or:     // T_OR:

                    return "||";

                case ExpressionKind.not:

                    return "!";

                case ExpressionKind.Cast:

                    CSharpType ctype = new CSharpType();

                    expression.type.Accept(ctype);

                    return String.Format("({0})", ctype.ToString()); ;

                default:

                    return Enum.GetName(typeof(ExpressionKind), expression.kind);

            }

        }

        public override void visit<T>(ValueExpression<T> valueExpression)

        {

            if (valueExpression.value == null)

                m_emitter.Append("null");

            else if (valueExpression is ValueExpression<bool>)

                m_emitter.Append(valueExpression.value.ToString().ToLower());

            else

                m_emitter.Append(valueExpression.value.ToString());

        }

        public override void visit(IdentifierExpression identifierExpression)

        {

            if (identifierExpression.identifier.kind == IdentifierKind.LandmarkIdentifier)

            {

                LandmarkIdentifier lmid = (LandmarkIdentifier)identifierExpression.identifier;

                QrType qr = (QrType)lmid.type;

                m_emitter.Append(qr.landmarks.IndexOf(lmid));

                return;

            }

            if (identifierExpression.identifier.kind == IdentifierKind.EnumIdentifier)

            {

                m_emitter.Append(GetIdentifierString(((EnumIdentifier)identifierExpression.identifier).type.identifier.tokenText));

                m_emitter.Append(".");

            }

            m_emitter.Append(GetIdentifierString(identifierExpression.identifier.tokenText));

        }

        public override void visit(TypeExpression typeExpression)

        {

            if (typeExpression.type.kind != TypeKind.QrType &&

                typeExpression.type.kind != TypeKind.EnumeratedType)

                m_emitter.Append(GetIdentifierString(typeExpression.type.identifier.tokenText));

        }

        public override void visit(ObjectConstructor objectConstructor)

        {

            int num = m_constructors.Count;

            m_constructors.Add(objectConstructor);

            if (objectConstructor.givenObjectName != null)

                m_emitter.Append(String.Format("new {0}(this,{1},{2})", GetIdentifierString(objectConstructor.type.identifier.tokenText), num, objectConstructor.givenObjectName));

            else

                m_emitter.Append(String.Format("new {0}(this,{1})", GetIdentifierString(objectConstructor.type.identifier.tokenText), num));

        }

        public override void visit(ListConstructor listConstructor)

        {

            if (listConstructor.hasComprehension)

            {

                // we need a helper for this.

                string helpername = String.Format("list_constr_helper_{0}", ((uint)listConstructor.GetHashCode()).ToString());

                m_emitter.Append(String.Format("{0}(new TUG.Mogentes.Codegen.CSharp.UlyssesList<object>())",

                    helpername));

                OoaCodeEmitter helperEmitter = new OoaCodeEmitter();

                helperEmitter.AppendLine(String.Format(

                    "public TUG.Mogentes.Codegen.CSharp.UlyssesList<object> {0} (TUG.Mogentes.Codegen.CSharp.UlyssesList<object> newList){{",

                     helpername));

                foreach (var sym in listConstructor.comprehensionVariables.symbolList)

                {

                    CSharpType atype = new CSharpType();

                    sym.type.Accept(atype);

                    if (sym.type.IsNumeric())

                        helperEmitter.AppendLine(String.Format("for ({0} {1} = {2}; {1} <= {3}; {1}++) {{",

                             atype.ToString(), CSharpIdentifier.GetIdentifierString(sym.tokenText), UlyssesType.Low(sym.type), UlyssesType.High(sym.type)));

                    else

                        throw new NotImplementedException();

                }

                StringBuilder helperhelper = new StringBuilder();

                string guardexpr = "true";

                if (listConstructor.comprehension != null)

                {

                    CSharpExpression expr = new CSharpExpression(helperhelper);

                    listConstructor.comprehension.Accept(expr);

                    guardexpr = expr.ToString();

                }

                CSharpExpression expr2 = new CSharpExpression(helperhelper);

                listConstructor.elements[0].Accept(expr2);

                helperEmitter.AppendLine(String.Format("if ({0}) {{", guardexpr));

                helperEmitter.AppendLine(String.Format("newList.Add({0});", expr2.ToString()));

                helperEmitter.AppendLine("}");

                foreach (var sym in listConstructor.comprehensionVariables.symbolList)

                {

                    helperEmitter.AppendLine("}");

                }

                helperEmitter.AppendLineIncIndent("return newList;");

                helperEmitter.AppendLine("}");

                m_helpers.Append(helperEmitter.ToString());

                m_helpers.Append(helperhelper.ToString());

            }

            else

            {

                m_emitter.Append("new TUG.Mogentes.Codegen.CSharp.UlyssesList<object>(");

                int i = 0;

                if (listConstructor.elements.Count > 0)

                {

                    m_emitter.Append("new object[] { ");

                    foreach (var x in listConstructor.elements)

                    {

                        if (i != 0)

                            m_emitter.Append(",");

                        else

                            i++;

                        x.Accept(this);

                    }

                    m_emitter.Append(" }");

                }

                m_emitter.Append(")");

            }

        }

        public override void visit(SetConstructor setConstructor)

        {

            throw new NotImplementedException();

        }

        public override void visit(MapConstructor mapConstructor)

        {

            throw new NotImplementedException();

        }

        public override void visit(TupleConstructor tupleConstructor)

        {

            m_emitter.Append(String.Format("new {0}(", GetIdentifierString(tupleConstructor.tupleType.tokenText)));

            int i = 0;

            foreach (var arg in tupleConstructor.values)

            {

                if (i != 0)

                    m_emitter.Append(",");

                else

                    i++;

                arg.Accept(this);

            }

            m_emitter.Append(")");

        }

        public override void visit(QValConstructor qValConstructor)

        {

            StringBuilder helpers = new StringBuilder();

            string landmarkOne = "null";

            if (qValConstructor.value.Length >= 1 && qValConstructor.value[0] != null)

            {

                CSharpExpression lndmrk1 = new CSharpExpression(helpers);

                qValConstructor.value[0].Accept(lndmrk1);

                landmarkOne = lndmrk1.ToString();

            }

            string landmarkTwo = "null";

            if (qValConstructor.value.Length >= 2 && qValConstructor.value[1] != null)

            {

                CSharpExpression lndmrk = new CSharpExpression(helpers);

                qValConstructor.value[1].Accept(lndmrk);

                landmarkTwo = lndmrk.ToString();

            }

            string derivation = "null";

            if (qValConstructor.valueDeriv != QValDeriv.DonTCare)

            {

                derivation = Enum.Format(typeof(QValDeriv), qValConstructor.valueDeriv, "d");

            }

            m_helpers.Append(helpers.ToString());

            m_emitter.Append(String.Format("new UlyssesQualitativeValue({0},{1},{2})", landmarkOne, landmarkTwo, derivation));

        }

        public override void visit(AccessExpression accessExpression)

        {

            if (accessExpression.left.type.kind != TypeKind.QrType &&

                accessExpression.left.type.kind != TypeKind.EnumeratedType)

            {

                // enums and qr types are directly (statically) converted to nums...

                VisitSub(accessExpression.left, accessExpression);

                m_emitter.Append(".");

            }

            VisitSub(accessExpression.right, accessExpression);

        }

        public override void visit(BinaryOperator binaryOperator)

        {

            m_emitter.Append("(");

            VisitSub(binaryOperator.left, binaryOperator);

            m_emitter.Append(") ");

            m_emitter.Append(OperatorString(binaryOperator));

            m_emitter.Append(" (");

            VisitSub(binaryOperator.right, binaryOperator);

            m_emitter.Append(")");

        }

        public override void visit(TernaryOperator ternaryOperator)

        {

            m_emitter.Append("(");

            VisitSub(ternaryOperator.left, ternaryOperator);

            m_emitter.Append(" ? ");

            VisitSub(ternaryOperator.mid, ternaryOperator);

            m_emitter.Append(" : ");

            VisitSub(ternaryOperator.right, ternaryOperator);

            m_emitter.Append(")");

        }

        public override void visit(TupleMapAccessExpression tupleMapAccessExpression)

        {

            throw new NotImplementedException();

            /*VisitSub(tupleMapAccessExpression.argument, tupleMapAccessExpression);

            VisitSub(tupleMapAccessExpression.child, tupleMapAccessExpression);*/

        }

        public override void visit(ForallQuantifier quantifier)

        {

            throw new NotImplementedException();

            /*foreach (var lvar in quantifier.symbols.symbolList)

                VisitSub(lvar, quantifier);

            VisitSub(quantifier.child, quantifier);*/

        }

        public override void visit(ExistsQuantifier quantifier)

        {

            throw new NotImplementedException();

            /*foreach (var lvar in quantifier.symbols.symbolList)

                VisitSub(lvar, quantifier);

            VisitSub(quantifier.child, quantifier);*/

        }

        public override void visit(UnaryOperator unaryOperator)

        {

            m_emitter.Append(" ");

            m_emitter.Append(OperatorString(unaryOperator));

            m_emitter.Append("(");

            VisitSub(unaryOperator.child, unaryOperator);

            m_emitter.Append(")");

        }

        public override string ToString()

        {

            return m_emitter.ToString();

        }

        public CSharpExpression(StringBuilder helpers)

            : base()

        {

            m_helpers = helpers;

        }

    }

}