SingleIdentifierExpression.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- //
// Project rROTOR                                                             //
// -------------------------------------------------------------------------- //
// File: SingleIdentifierExpression.cs                                        //
// Authors: Cristina Gonzalez Muñoz  -  cristi.gm@gmail.com                   //
//          Francisco Ortin - francisco.ortin@gmail.com                       //
// Description:                                                               //
//    Encapsulates a identifier expression of our programming language.       //
//    Inheritance: Expression.                                                //
//    Implements Composite pattern [Leaf].                                    //
//    Implements Visitor pattern [Concrete Element].                          //
// -------------------------------------------------------------------------- //
// Create date: 05-12-2006                                                    //
// Modification date: 06-04-2007                                              //

using System;
using System.Collections.Generic;
using System.Text;

using Symbols;
using Tools;
using TypeSystem;
using ErrorManagement;
using CodeGeneration;
using TypeSystem.Operations;
using AST.Operations;

namespace AST {
    #region enum IdentifierMode

    public enum IdentifierMode {
        Instance,
        UserType,
        NameSpace
    }

    #endregion

    public class SingleIdentifierExpression : IdentifierExpression {
        #region Field

        private IdentifierMode idMode;

        private Symbol symbol;

        private int indexOfSSA;

        private string ilName = "";

        private ILReservedWords ilReservedWords;
        #endregion

        #region Properties

        public IdentifierMode IdMode {
            set { this.idMode = value; }
            get { return this.idMode; }
        }

        public Symbol IdSymbol {
            get { return this.symbol; }
            set { this.symbol = value; }
        }

        public int IndexOfSSA {
            get { return this.indexOfSSA; }
            set { this.indexOfSSA = value; }
        }

        public TypeExpression FrozenTypeExpression {
            get { return this.frozenTypeExpression; }
            set { this.frozenTypeExpression = value; }
        }

        #region ILName

        public string ILName {

            get {
                // the ilName field is alredy defined, so it is returned
                if (!this.ilName.Equals(""))
                    return this.ilName;
                // ilName is blank
                // if the node is provided by SSA algorithm, the proper subscript is added as a number 
                // to the parameter, and assigned to this.ilName
                if (this.indexOfSSA != -1)
                    SSARename();
                else // assign this.Identifier to ilName, if it's a keyworkd of IL Language the returned string is sourronded by a pair of '
                    this.ilName = this.ilReservedWords.MakeILComplaint(this.Identifier);

                return this.ilName;
            }
        }
        private void SSARename() {
            StringBuilder aux = new StringBuilder();
            aux.AppendFormat("{0}__{1}", this.Identifier, this.indexOfSSA);
            this.ilName = aux.ToString();
        }

        #endregion

        #endregion

        #region Constructor

        public SingleIdentifierExpression(string idenfifier, Location location)
            : base(location) {

            this.Identifier = idenfifier;
            this.idMode = IdentifierMode.Instance;
            this.indexOfSSA = -1;
            this.ilReservedWords = new ILReservedWords();
        }

        #endregion

        #region Accept()

        public override Object Accept(Visitor v, Object o) {
            return v.Visit(this, o);
        }
        #endregion

        #region Dispatcher AstOperation
        public override object AcceptOperation(AstOperation op, object arg) {
            return op.Exec(this, arg);
        }

        #endregion

        #region Equals&GetHashCode
        public override bool Equals(object obj) {
            if (this.GetHashCode() != obj.GetHashCode())
                return false;
            SingleIdentifierExpression singleId = obj as SingleIdentifierExpression;
            if (singleId == null)
                return false;
            return this.Identifier.Equals(singleId.Identifier) && this.indexOfSSA == singleId.indexOfSSA;
        }
        public override int GetHashCode() {
            return this.Identifier.GetHashCode() * this.indexOfSSA;
        }
        #endregion
    }
}