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 TUG.Mogentes.Codegen;

using Antlr.Runtime;

namespace TUG.Mogentes

{

    public enum IdentifierKind

    {

        TypeIdentifier,         // some named type

        EnumIdentifier,         // identifier of enumerated type

        LandmarkIdentifier,     // landmark

        AttributeIdentifier,    // global attribute

        LocalVariableIdentifier,// local variable

        ParameterIdentifier,     // method/named action argument

        ExpressionVariableIdentifier, // var in an expression

        MethodIdentifier,       // a method

        NamedActionIdentifier,  // a named action

        Module,                 // the main module - actually this has no name...

        List,

        Constant

    }

    /* ABSTRACT class Identifier.

     * */

    public abstract class Identifier : UlyssesBasicClass, IAst, IComparable

    {

        protected int m_line;

        protected int m_column;

        protected IScope m_definingScope;

        protected IdentifierKind m_identifierKind;

        protected string m_tokenText;

        protected UlyssesType m_Type;

        // basic attributes of an Identifier

        public IdentifierKind kind { get { return m_identifierKind; } } // kind of identifier

        public UlyssesType type { get { return m_Type; } }   // type of identifier

        public IScope definingScope { get { return m_definingScope; } } // scope where it's defined

        // from lexer

        public string tokenText { get { return m_tokenText; } }

        public int line { get { return m_line; } }

        public int column { get { return m_column; } }

        public AstNodeTypeEnum nodeType { get { return AstNodeTypeEnum.identifier; } }

        public Identifier(IToken aToken,

                          UlyssesType aType,

                          IdentifierKind aKind,

                          IScope aDefiningScope)

        {

            m_tokenText = aToken.Text;

            m_line = aToken.Line;

            m_column = aToken.CharPositionInLine;

            m_Type = aType;

            m_identifierKind = aKind;

            m_definingScope = aDefiningScope;

        }

        public Identifier(string name, UlyssesType aType, IdentifierKind aKind, IScope aDefiningScope)

        {

            m_tokenText = name;

            m_line = 0;

            m_column = 0;

            m_Type = aType;

            m_identifierKind = aKind;

            m_definingScope = aDefiningScope;

        }

        public Identifier(Identifier toCopy)

        {

            m_tokenText = toCopy.m_tokenText;

            m_line = toCopy.m_line;

            m_column = toCopy.m_column;

            m_Type = toCopy.m_Type;

            m_identifierKind = toCopy.m_identifierKind;

            m_definingScope = toCopy.m_definingScope;

        }

        public virtual Identifier Clone()

        {

            throw new NotImplementedException();

        }

        public virtual void Accept(IAstVisitor visitor)

        {

            throw new NotImplementedException();

        }

        public void SetType(UlyssesType aType)

        {

            if (aType == null)

                throw new ArgumentException("New type can not be null.");

            m_Type = aType;

        }

        public void SetTokenText(string aText)

        {

            m_tokenText = aText;

        }

        public override string ToString()

        {

            return tokenText;

        }

        public int CompareTo(object obj)

        {

            if (obj is Identifier)

                return tokenText.CompareTo(obj.ToString());

            else

                throw new InvalidCastException();

        }

    }

    ///////////////////////////////////////////////

    ///  Value Identifiers

    ///  

    public abstract class ValueIdentifier : Identifier

    {

        public ValueIdentifier(IToken aToken,

                          UlyssesType aType,

                          IdentifierKind aKind,

                          IScope aDefiningScope)

            : base(aToken, aType, aKind, aDefiningScope)

        { }

        public ValueIdentifier(ValueIdentifier toCopy)

            : base(toCopy)

        { }

    }

    public sealed class ConstantIdentifier : ValueIdentifier

    {

        private Expression m_value;

        public Expression Value { get { return m_value; } }

        public ConstantIdentifier(IToken aToken,

                          Expression value,

                          IScope aDefiningScope)

            : base(aToken, null, IdentifierKind.Constant, aDefiningScope)

        {

            m_value = value;

        }

        public ConstantIdentifier(ConstantIdentifier toCopy)

            : base(toCopy)

        {

            m_value = toCopy.m_value;

        }

        public void SetValue(Expression aValue)

        {

            m_value = aValue;

        }

        public override Identifier Clone()

        {

            return this;

        }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

    }

    public sealed class EnumIdentifier : ValueIdentifier

    {

        private int value;

        private bool haveValue;

        public int Value { get { return value; } }

        public bool HaveValue { get { return haveValue; } }

        public EnumIdentifier(IToken aToken,

                          EnumType aType,

                          IScope aDefiningScope)

            : base(aToken, aType, IdentifierKind.EnumIdentifier, aDefiningScope)

        {

            haveValue = false;

        }

        public EnumIdentifier(IToken aToken,

                          int aValue,

                          EnumType aType,

                          IScope aDefiningScope)

            : base(aToken, aType, IdentifierKind.EnumIdentifier, aDefiningScope)

        {

            haveValue = true;

            value = aValue;

        }

        public EnumIdentifier(EnumIdentifier toCopy)

            : base(toCopy)

        {

            value = toCopy.value;

            haveValue = toCopy.haveValue;

        }

        public override Identifier Clone()

        {

            return this;

        }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

    }

    public sealed class LandmarkIdentifier : ValueIdentifier

    {

        public LandmarkIdentifier(IToken aToken,

                          QrType aType,

                          IScope aDefiningScope)

            : base(aToken, aType, IdentifierKind.LandmarkIdentifier, aDefiningScope)

        { }

        public LandmarkIdentifier(LandmarkIdentifier toCopy)

            : base(toCopy)

        { }

        public override Identifier Clone()

        {

            return this;

        }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

    }

    ///////////////////////////////////////////////

    ///  Variable Identifiers

    ///  

    public abstract class ValueReferenceIdentifier : Identifier

    {

        public ValueReferenceIdentifier(IToken aToken,

                          UlyssesType aType,

                          IdentifierKind aKind,

                          IScope aDefiningScope)

            : base(aToken, aType, aKind, aDefiningScope)

        { }

        public ValueReferenceIdentifier(ValueReferenceIdentifier toCopy)

            : base(toCopy)

        { }

        public ValueReferenceIdentifier(string name, UlyssesType aType, IdentifierKind aKind, IScope aDefiningScope) :

            base(name, aType, aKind, aDefiningScope)

        { }

    }

    public sealed class AttributeIdentifier : ValueReferenceIdentifier

    {

        private Expression m_initializer;

        private bool m_isStatic;

        private bool m_isObservable;    // used for qualitative values

        private bool m_isControllable;  // used for qualitative values

        public Expression initializer { get { return m_initializer; } }

        public bool isStatic { get { return m_isStatic; } }

        public bool isObservable { get { return m_isObservable; } }

        public bool isControllable { get { return m_isControllable; } }

        public AttributeIdentifier(IToken aToken,

                          UlyssesType aType,

                          IScope aDefiningScope,

                          Expression anInitializer,

                          bool isStatic,

                          bool isObservable,

                          bool isControllable)

            : base(aToken, aType, IdentifierKind.AttributeIdentifier, aDefiningScope)

        {

            m_initializer = anInitializer;

            m_isStatic = isStatic;

            m_isControllable = isControllable;

            m_isObservable = isObservable;

        }

        public AttributeIdentifier(AttributeIdentifier toCopy)

            : base(toCopy)

        {

            m_initializer = toCopy.initializer;

            m_isStatic = toCopy.m_isStatic;

            m_isControllable = toCopy.m_isControllable;

            m_isObservable = toCopy.m_isObservable;

        }

        public override Identifier Clone()

        {

            return new AttributeIdentifier(this);

        }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

        public void SetInitializer(Expression newExpr)

        {

            if (newExpr == null)

                throw new ArgumentException();

            m_initializer = newExpr;

        }

    }

    public class LocalVariableIdentifier : ValueReferenceIdentifier

    {

        public LocalVariableIdentifier(IToken aToken,

                          UlyssesType aType,

                          IScope aDefiningScope)

            : base(aToken, aType, IdentifierKind.LocalVariableIdentifier, aDefiningScope)

        { }

        public LocalVariableIdentifier(LocalVariableIdentifier toCopy)

            : base(toCopy)

        { }

        public override Identifier Clone()

        {

            return new LocalVariableIdentifier(this);

        }

        public LocalVariableIdentifier(string name, UlyssesType aType, IdentifierKind aKind, IScope aDefiningScope)

            : base(name, aType, aKind, aDefiningScope)

        { }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

    }

    public sealed class ParameterIdentifier : LocalVariableIdentifier

    {

        public ParameterIdentifier(IToken aToken,

                          UlyssesType aType,

                          IScope aDefiningScope)

            : base(aToken, aType, aDefiningScope)

        {

            m_identifierKind = IdentifierKind.ParameterIdentifier;

        }

        public ParameterIdentifier(string name, UlyssesType aType, IScope aDefiningScope)

            : base(name, aType, IdentifierKind.ParameterIdentifier, aDefiningScope)

        { }

        public ParameterIdentifier(ParameterIdentifier toCopy)

            : base(toCopy)

        { }

        public override Identifier Clone()

        {

            return new ParameterIdentifier(this);

        }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

    }

    public sealed class ExpressionVariableIdentifier : LocalVariableIdentifier

    {

        private bool m_isInitialized;

        public bool initialized { get { return m_isInitialized; } }

        public ExpressionVariableIdentifier(IToken aToken,

                          UlyssesType aType,

                          IScope aDefiningScope)

            : base(aToken, aType, aDefiningScope)

        {

            m_identifierKind = IdentifierKind.ExpressionVariableIdentifier;

        }

        public ExpressionVariableIdentifier(string name, int line, int col)

            : base(name, null, IdentifierKind.ExpressionVariableIdentifier, null)

        {

            m_line = line;

            m_column = col;

            m_isInitialized = false;

        }

        public ExpressionVariableIdentifier(ExpressionVariableIdentifier toCopy)

            : base(toCopy)

        {

            m_line = toCopy.m_line;

            m_column = toCopy.m_column;

            m_isInitialized = toCopy.m_isInitialized;

        }

        public override Identifier Clone()

        {

            return new ExpressionVariableIdentifier(this);

        }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

        public void SetInitialized(bool newValue)

        {

            m_isInitialized = newValue;

        }

    }

    ///////////////////////////////////////////////

    ///  Type Identifier

    ///  

    public class TypeIdentifier : Identifier

    {

        public string prefix;

        protected TypeIdentifier(IToken aToken,

                          UlyssesType aType,

                            IdentifierKind someKind,

                          IScope aDefiningScope)

            : base(aToken, aType, someKind, aDefiningScope)

        { }

        protected TypeIdentifier(string aToken,

                          UlyssesType aType,

                            IdentifierKind someKind,

                          IScope aDefiningScope)

            : base(aToken, aType, someKind, aDefiningScope)

        { }

        public TypeIdentifier(IToken aToken,

                          UlyssesType aType,

                          IScope aDefiningScope)

            : base(aToken, aType, IdentifierKind.TypeIdentifier, aDefiningScope)

        { }

        public TypeIdentifier(string aName,

                          UlyssesType aType,

                          IScope aDefiningScope)

            : base(aName, aType, IdentifierKind.TypeIdentifier, aDefiningScope)

        { }

        public TypeIdentifier(TypeIdentifier toCopy)

            : base(toCopy)

        {

            this.prefix = toCopy.prefix;

        }

        public override Identifier Clone()

        {

            return new TypeIdentifier(this);

        }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

    }

    public sealed class SelfTypeIdentifier : TypeIdentifier

    {

        public SelfTypeIdentifier(string aName,

                          UlyssesType aType,

                          IScope aDefiningScope)

            : base(aName, aType, aDefiningScope)

        { }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

    }

    ///////////////////////////////////////////////

    ///  Scope Identifiers

    ///  

    public abstract class Scope : TypeIdentifier, IScope

    {

        protected SymbolTable m_symbolTable;

        public Scope(IToken aToken,

                     UlyssesType aType,

                     IdentifierKind aKind,

                     IScope aDefiningScope)

            : base(aToken, aType, aKind, aDefiningScope)

        {

            m_symbolTable = new SymbolTable();

        }

        public Scope(string aName,

                     UlyssesType aType,

                     IdentifierKind aKind,

                     IScope aDefiningScope)

            : base(aName, aType, aKind, aDefiningScope)

        {

            m_symbolTable = new SymbolTable();

        }

        public Scope(Scope toCopy)

            : base(toCopy)

        {

            m_symbolTable = toCopy.symbolTable;

        }

        public SymbolTable symbolTable { get { return m_symbolTable; } }

        public IScope GetParentScope()

        {

            return m_definingScope;

        }

        public void SetParentScope(IScope parentScope)

        {

            m_definingScope = parentScope;

        }

        public virtual void AddIdentifier(Identifier anIdentifier, object tag)

        {

            m_symbolTable.AddIdentifier(anIdentifier);

        }

        public Identifier ResolveIdentifier(string aName)

        {

            if (m_symbolTable.Defined(aName))

                return m_symbolTable.Get(aName);

            else

                return null;

        }

    }

    public abstract class FunctionIdentifier : Scope

    {

        private Block m_body;

        private List<ParameterIdentifier> m_parameter = new List<ParameterIdentifier>();

        public Block body { get { return m_body; } }

        public List<ParameterIdentifier> parameter { get { return m_parameter; } }

        public FunctionIdentifier(IToken aToken,

                          UlyssesType aType,

                          IdentifierKind aKind,

                          IScope aDefiningScope)

            : base(aToken, aType, aKind, aDefiningScope)

        { }

        public FunctionIdentifier(FunctionIdentifier toCopy)

            : base(toCopy)

        {

            m_body = toCopy.m_body;

            m_parameter = new List<ParameterIdentifier>(toCopy.m_parameter);

        }

        public void SetBody(Block body)

        {

            m_body = body;

        }

        public void AddParameter(ParameterIdentifier aParameter)

        {

            m_parameter.Add(aParameter);

            AddIdentifier(aParameter, null);

        }

    }

    public sealed class MethodIdentifier : FunctionIdentifier

    {

        public MethodIdentifier(IToken aToken,

                          UlyssesType aType,

                          IScope aDefiningScope)

            : base(aToken, aType, IdentifierKind.MethodIdentifier, aDefiningScope)

        { }

        public MethodIdentifier(MethodIdentifier toCopy)

            : base(toCopy)

        { }

        public override Identifier Clone()

        {

            return new MethodIdentifier(this);

        }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

    }

    public sealed class NamedActionIdentifier : FunctionIdentifier

    {

        public NamedActionIdentifier(IToken aToken,

                          UlyssesType aType,

                          IScope aDefiningScope)

            : base(aToken, aType, IdentifierKind.NamedActionIdentifier, aDefiningScope)

        { }

        public NamedActionIdentifier(NamedActionIdentifier toCopy)

            : base(toCopy)

        { }

        public override Identifier Clone()

        {

            return new NamedActionIdentifier(this);

        }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

    }

    public class Module : Scope

    {

        //protected List<OpaqueType> m_typesToFixUp;

        //protected List<Expression> m_referencesToResolve;

        //public List<OpaqueType> typesToFixUp { get { return m_typesToFixUp; } }

        //public List<Expression> referencesToResolve { get { return m_referencesToResolve; } }

        public Module()

            : base("@Module", null, IdentifierKind.Module, null)

        {

            //m_typesToFixUp = new List<OpaqueType>();

            // m_referencesToResolve = new List<Expression>();

        }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

    }

    public sealed class MainModule : Module

    {

        private IdentifierList m_systemDescription;

        private ActionSystem m_instance;

        public IdentifierList systemDescription { get { return m_systemDescription; } }

        public ActionSystem instance { get { return m_instance; } }

        public MainModule()

            : base()

        {

            m_systemDescription = null;

        }

        public void SetSystemDescription(IdentifierList aDescr)

        {

            m_systemDescription = aDescr;

        }

        public void SetInstance(ActionSystem anObject)

        {

            m_instance = anObject;

        }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

    }

    ///////////////////////////////////////////////

    ///  Identifier List

    ///  

    public enum IdentifierListType { normal, nondeterministic, seqential, prioritized }

    public abstract class IdentifierList : Identifier

    {

        private LinkedList<Identifier> m_list;

        private IdentifierListType m_type;

        public LinkedList<Identifier> identifiers { get { return m_list; } }

        public IdentifierListType listType { get { return m_type; } }

        public IdentifierList(IdentifierListType aConcatType)

            : base("list", null, IdentifierKind.List, null)

        {

            m_list = new LinkedList<Identifier>();

            m_type = aConcatType;

        }

        public void AddElement(Identifier toAdd)

        {

            m_list.AddLast(toAdd);

        }

    }

    public sealed class NondetIdentifierList : IdentifierList

    {

        public NondetIdentifierList()

            : base(IdentifierListType.nondeterministic)

        { }

        public NondetIdentifierList(IdentifierList aParent)

            : base(IdentifierListType.nondeterministic)

        {

            if (aParent != null)

                aParent.AddElement(this);

        }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

    }

    public sealed class SeqIdentifierList : IdentifierList

    {

        public SeqIdentifierList()

            : base(IdentifierListType.seqential)

        { }

        public SeqIdentifierList(IdentifierList aParent)

            : base(IdentifierListType.seqential)

        {

            if (aParent != null)

                aParent.AddElement(this);

        }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

    }

    public sealed class PrioIdentifierList : IdentifierList

    {

        public PrioIdentifierList()

            : base(IdentifierListType.prioritized)

        { }

        public PrioIdentifierList(IdentifierList aParent)

            : base(IdentifierListType.prioritized)

        {

            if (aParent != null)

                aParent.AddElement(this);

        }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

    }

    public sealed class UnspecIdentifierList : IdentifierList

    {

        public UnspecIdentifierList()

            : base(IdentifierListType.normal)

        { }

        public UnspecIdentifierList(IdentifierList aParent)

            : base(IdentifierListType.normal)

        {

            if (aParent != null)

                aParent.AddElement(this);

        }

        public override void Accept(IAstVisitor visitor)

        {

            visitor.visit(this);

        }

    }

}