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)

  */

using System;

using System.Collections.Generic;

using System.Text;

using TUG.Mogentes;

using TUG.Mogentes.Codegen.CSharp;

namespace TUG.Mogentes.Codegen

{

    public sealed class OoaCSharpInitVisitor : OoaCompleteAstTraversalVisitor

    {

        private readonly string SimulationNameSpace = "TUG.Mogentes.Codegen.CSharp.Simulation";

        private OoaCodeEmitter emitter;

        private List<UlyssesType> hiddenTypesStillToEmit = new List<UlyssesType>();

        private StringBuilder helpers = new StringBuilder();

        private List<OoActionSystemType> autoConsList = new List<OoActionSystemType>();

        private int m_maxObjectNameLength = 0;

        private List<string> m_objectNames = new List<string>();

        private List<OoActionSystemInstance> m_initialObjectWorkingSet = new List<OoActionSystemInstance>();

        public int maxObjectNameLength { get { return m_maxObjectNameLength; } }

        public List<string> objectNames { get { return m_objectNames; } }

        public List<OoActionSystemInstance> initialObjectWorkingSet { get { return m_initialObjectWorkingSet; } }

        public void Error(int line, int pos, string p)

        {

            ParserError error = new ParserError(m_ParserState.filename, line, pos, p);

            m_ParserState.AddErrorMessage(error);

        }

        private void Error(OoActionSystemInstance id, string p)

        {

            int line = id.Type.identifier.line;

            int pos = id.Type.identifier.column;

            ParserError error = new ParserError(m_ParserState.filename, line, pos, p);

            m_ParserState.AddErrorMessage(error);

        }

        private void Warning(OoActionSystemType atype, string p)

        {

            ParserWarning warn = new ParserWarning(m_ParserState.filename, atype.identifier.line,

                atype.identifier.column, p);

            m_ParserState.AddWarningMessage(warn);

        }

        private string GetIdentifierString(string anIdentifier)

        {

            return CSharpIdentifier.GetIdentifierString(anIdentifier);

        }

        private List<OoActionSystemType> AstTypeLookup = new List<OoActionSystemType>();

        /// <summary>

        /// here we are called when a new object has been created

        /// </summary>

        internal void visit(TUG.Mogentes.Codegen.CSharp.UlyssesActionSystemClass ulyssesActionSystemClass, int ConstrNum)

        {

            OoActionSystemType aParentType =

                ulyssesActionSystemClass.parent != null ?

                    AstTypeLookup[ulyssesActionSystemClass.parent._AstTypeLookupIndex] : null;

            OoActionSystemType atype = AstTypeLookup[ulyssesActionSystemClass._AstTypeLookupIndex];

            OoActionSystemInstance aParentInstance =

                ulyssesActionSystemClass.parent != null ?

                ulyssesActionSystemClass.parent.objectInstance : null;

            C5.HashSet<UlyssesType> seenTypes = new C5.HashSet<UlyssesType>();

            StringBuilder instantiationPath = new StringBuilder();

            if (aParentInstance != null)

            {

                OoActionSystemInstance tmp = aParentInstance;

                while (tmp != null)

                {

                    instantiationPath.Append(String.Format("<-{0}", tmp.Name));

                    seenTypes.Add(tmp.Type);

                    tmp = tmp.ParentObject;

                }

            }

            UlyssesType tmpType = atype;

            while (tmpType != null)

            {

                if (seenTypes.Contains(tmpType))

                {

                    throw new UlyssesCompileException(String.Format("Cycle in object creation. {0}", instantiationPath.ToString()));

                }

                else

                    tmpType = ((OoActionSystemType)tmpType).baseType;

            }

            ulyssesActionSystemClass.objectInstance =

                new OoActionSystemInstance(ulyssesActionSystemClass.objectName, atype, ulyssesActionSystemClass, aParentInstance);

            // update max length of object name

            m_maxObjectNameLength = ulyssesActionSystemClass.objectName.Length > m_maxObjectNameLength

                ? ulyssesActionSystemClass.objectName.Length : m_maxObjectNameLength;

            // add to list of object names

            m_objectNames.Add(ulyssesActionSystemClass.objectName);

            // add to global list of initial objects

            m_initialObjectWorkingSet.Add(ulyssesActionSystemClass.objectInstance);

            m_ParserState.AddMessage(new ParserMessage(m_ParserState.filename,

                atype.identifier.line, atype.identifier.column, String.Format("Creating object: {0}", ulyssesActionSystemClass.objectName)));

            atype.objects.Add(ulyssesActionSystemClass.objectInstance);

            // also add the object to the base types

            atype = atype.baseType;

            while (atype != null)

            {

                atype.derivedObjects.Add(ulyssesActionSystemClass.objectInstance);

                atype = atype.baseType;

            }

            atype = null;

            if (ConstrNum >= 0)

                CSharpExpression.constructors[ConstrNum].AddInstance(ulyssesActionSystemClass.objectInstance);

        }

        private string GetCSharpType(UlyssesType aType)

        {

            if (aType.isAnonymousType)

                hiddenTypesStillToEmit.Add(aType);

            CSharpType sharptype = new CSharpType();

            aType.Accept(sharptype);

            return sharptype.ToString();

        }

        private string GetCSharpExpression(Expression anExpression)

        {

            CSharpExpression sharpexpression = new CSharpExpression(helpers);

            anExpression.Accept(sharpexpression);

            return sharpexpression.ToString();

        }

        private void StartSimulation(string p)

        {

            try

            {

                // set reference

                TUG.Mogentes.Codegen.CSharp.UlyssesActionSystemClass.objectInstantiator = this;

                // compile

                Uri path = new Uri(System.Reflection.Assembly.GetExecutingAssembly().CodeBase);

                String[] RefAssemblies = { path.LocalPath };

                System.Reflection.Assembly simulationCode = CSharpCodeCompiler.BuildAssembly(new string[] { p }, RefAssemblies);

                // execute system initialization

                CSharpCodeCompiler.ExecuteCode(simulationCode, SimulationNameSpace + ".SimulationCore", "Main", "Start", new object[] { });

            }

            catch (UlyssesCompileException e)

            {

                ParserError error = new ParserError("ObjectInstantiationVisitor.cs", 0, 0, e.Message);

                m_ParserState.AddErrorMessage(error);

            }

        }

        /// <summary>

        /// generates C# code that describes initialization of the action systems

        /// this is used to determine the initial working set of classes.

        /// </summary>

        private void Emit(OoActionSystemType ooActionSystemType)

        {

            List<AttributeIdentifier> initializers = new List<AttributeIdentifier>();

            helpers = new StringBuilder();

            if (ooActionSystemType.baseType == null)

                emitter.AppendLineIncIndent(String.Format("public class {0} : TUG.Mogentes.Codegen.CSharp.UlyssesActionSystemClass {{", GetIdentifierString(ooActionSystemType.identifier.tokenText)));

            else

                emitter.AppendLineIncIndent(String.Format("public class {0} : {1} {{", GetIdentifierString(ooActionSystemType.identifier.tokenText), GetIdentifierString(ooActionSystemType.baseType.identifier.tokenText)));

            foreach (var attr in ooActionSystemType.symbols.symbolList)

            {

                if (attr.kind == IdentifierKind.AttributeIdentifier)

                {

                    string staticdecl = ((AttributeIdentifier)attr).isStatic ? "static" : string.Empty;

                    emitter.AppendLine(String.Format("public {2} {0} {1};", GetCSharpType(attr.type), GetIdentifierString(attr.tokenText), staticdecl));

                    initializers.Add(((AttributeIdentifier)attr));

                }

            }

            // emit internal constructor that initializes object

            emitter.AppendLineIncIndent(String.Format("protected {0} (TUG.Mogentes.Codegen.CSharp.UlyssesActionSystemClass parent, int constrNum, int LookupIndex, string aGivenName): base(parent, constrNum, LookupIndex, aGivenName) {{", GetIdentifierString(ooActionSystemType.identifier.tokenText)));

            foreach (var attr in initializers)

                emitter.AppendLine(String.Format("{0} = {1};", GetIdentifierString(attr.tokenText), GetCSharpExpression(attr.initializer)));

            emitter.AppendLineDecIndent("}");

            // emit public constructor

            emitter.AppendLineIncIndent(String.Format("public {0} (TUG.Mogentes.Codegen.CSharp.UlyssesActionSystemClass parent, int constrNum): this(parent, constrNum,{1}, String.Empty) {{}}", GetIdentifierString(ooActionSystemType.identifier.tokenText), AstTypeLookup.Count));

            // emit public constructor with fixed name

            emitter.AppendLineIncIndent(String.Format("public {0} (TUG.Mogentes.Codegen.CSharp.UlyssesActionSystemClass parent, int constrNum, string aName): this(parent, constrNum,{1}, aName) {{}}", GetIdentifierString(ooActionSystemType.identifier.tokenText), AstTypeLookup.Count));

            AstTypeLookup.Add(ooActionSystemType);

            // emit helpers

            emitter.Append(helpers.ToString());

            emitter.AppendLineDecIndent("}");

            if (ooActionSystemType.autoConstruction)

                autoConsList.Add(ooActionSystemType);

        }

        /// <summary>

        /// Emits type definition for tuple 

        /// </summary>

        private void Emit(TupleType atupleType)

        {

            emitter.AppendLineIncIndent(String.Format("public class {0} {{", GetIdentifierString(atupleType.identifier.tokenText)));

            int i = 0;

            foreach (var it in atupleType.innerTypes)

            {

                emitter.AppendLine(String.Format("public {0} elem_{1};", GetCSharpType(it), i.ToString()));

                i++;

            }

            emitter.AppendLine(" /*constr*/ ");

            emitter.Append(String.Format("public {0} (", GetIdentifierString(atupleType.identifier.tokenText)));

            i = 0;

            foreach (var it in atupleType.innerTypes)

            {

                if (i != 0)

                    emitter.Append(",");

                emitter.Append(String.Format("{0} arg_{1}", GetCSharpType(it), i.ToString()));

                i++;

            }

            emitter.AppendLineIncIndent(") {");

            i = 0;

            foreach (var it in atupleType.innerTypes)

            {

                emitter.AppendLine(String.Format("elem_{0} = arg_{0};", i.ToString()));

                i++;

            }

            emitter.AppendLineDecIndent("}");

            emitter.AppendLineDecIndent("}");

        }

        /// <summary>

        /// Emits type definition for enum 

        /// </summary>

        private void Emit(EnumType anEnum)

        {

            emitter.Append(String.Format("public enum {0} {{", GetIdentifierString(anEnum.identifier.tokenText)));

            int i = 0;

            foreach (var it in anEnum.listOfEnumSymbols)

            {

                if (i != 0)

                    emitter.Append(", ");

                else

                    i++;

                emitter.Append(GetIdentifierString(it.tokenText));

            }

            emitter.AppendLine("}");

        }

        protected override void VisitAstElement(IAst element, IAst parent)

        {

            if (element.nodeType == AstNodeTypeEnum.type &&

                ((UlyssesType)element).kind == TypeKind.OoActionSystemType)

            {

                OoActionSystemType asystem = (OoActionSystemType)element;

                /*if (asystem.autoConstruction)

                    CheckForRecursiveNew(asystem);*/

                Emit((OoActionSystemType)element);

            }

            else if (element.nodeType == AstNodeTypeEnum.type &&

                ((UlyssesType)element).kind == TypeKind.TupleType)

            {

                Emit((TupleType)element);

            }

            else if (element.nodeType == AstNodeTypeEnum.type &&

                ((UlyssesType)element).kind == TypeKind.EnumeratedType)

            {

                Emit((EnumType)element);

            }

            else

                base.VisitAstElement(element, parent);

        }

        public override void visit(MainModule mainModule)

        {

            CSharpExpression.constructors.Clear(); 

            emitter.AppendLine("using System;");

            emitter.AppendLine("using System.Collections.Generic;");

            emitter.AppendLine("using System.Text;");

            emitter.AppendLine("using TUG.Mogentes.Codegen.CSharp;");

            emitter.AppendLine("");

            emitter.AppendLineIncIndent(String.Format("namespace {0} {{", SimulationNameSpace));

            base.visit(mainModule);

            emitter.AppendLine(" /* == anonymous types == */ ");

            foreach (var x in hiddenTypesStillToEmit)

            {

                // we only need to define tuples and enums..

                if (x.kind == TypeKind.TupleType)

                    Emit((TupleType)x);

                else if (x.kind == TypeKind.EnumeratedType)

                    Emit((EnumType)x);

            }

            emitter.AppendLine(" /* == create autocons objects == */ ");

            emitter.AppendLineIncIndent("namespace SimulationCore {");

            emitter.AppendLineIncIndent("public class Main {");

            emitter.AppendLineIncIndent("public static void Start(){");

            foreach (var x in autoConsList)

                emitter.AppendLine(String.Format("new {0}(null,-1 /*autocons*/);", GetIdentifierString(x.identifier.tokenText)));

            emitter.AppendLineDecIndent("}");

            emitter.AppendLineDecIndent("}");

            emitter.AppendLineDecIndent("}");

            emitter.AppendLineDecIndent("}");

            StartSimulation(emitter.ToString());

        }

        public override string ToString()

        {

            return emitter.ToString();

        }

        public OoaCSharpInitVisitor(ParserState state)

            : base(state)

        {

            emitter = new OoaCodeEmitter();

        }

    }

}