Symbol.cs

Go to the documentation of this file.

using Mercury.Exceptions;
using Mercury.Scanning;
using System;

namespace Mercury.Syntax
{
//=============================================================================
//  Symbol
//=============================================================================

    [Flags]
    public enum SymbolType
    {
        None        = 0,
        Epsilon     = 1,
        Terminal    = 2,
        Nonterminal = 4,
        Any         = Epsilon | Terminal | Nonterminal
    }

    public class Symbol : IEquatable<Symbol>, IComparable<Symbol>
    {
        //--[  Private methods  ]----------------------------------------------

        private bool IsValid()
        {
            return (Type == SymbolType.Epsilon)
                || (Type == SymbolType.Terminal)
                || (Type == SymbolType.Nonterminal);
        }

        //--[  Constructors  ]-------------------------------------------------

        public Symbol()
        {
            Name  = Defaults.Epsilon;
            Type  = SymbolType.Epsilon;
            Token = null;
        }

        public Symbol(string name)
            : this(name, SymbolType.Nonterminal | SymbolType.Terminal)
        { }

        public Symbol(string name, SymbolType type)
        {
            if (name == null) throw new ArgumentNullException("name");
            Type  = InferType(name) & type;
            Name  = (Type == SymbolType.Terminal) ? name.ToLower() : name;
            Token = null;

            if (!IsValid())   throw new InvalidSymbolException(this);
        }

        public Symbol(Token token)
        {
            if (token == null) throw new ArgumentNullException("token");

            Token = token;
            Name  = token.Value.ToLowerInvariant();
            Type  = InferType(Name) & SymbolType.Terminal;

            if (!IsValid()) throw new InvalidSymbolException(this);
        }

        //--[  Methods  ]------------------------------------------------------

        public static SymbolType InferType(string name)
        {
            // reject empty name
            if (string.IsNullOrEmpty(name)) return SymbolType.None;

            // some cool flags for convenience
            bool anyLetter   = false;
            bool allLetDig   = true;
            bool allLetDigEx = true;
            bool allDigits   = true;
            int  dotcount    = 0;

            // reject name containing special characters or separators
            // meanwhile compute predicate values
            for (int ix = 0; ix < name.Length; ++ix )
            {
                char c = name[ix];
                if (char.IsControl(c) || char.IsSeparator(c)) return SymbolType.None;
                if (c == '.') ++dotcount;

                anyLetter   |=  char.IsLetter(c);
                allDigits   &= (char.IsDigit(c) || (dotcount == 1) || ((ix == 0) && ("+-".IndexOf(c) != -1)));
                allLetDig   &=  char.IsLetterOrDigit(c);
                allLetDigEx &= (char.IsLetterOrDigit(c) || ("@_".IndexOf(c) != -1));
            }

            // check terminal b) condition
            if ((dotcount <= 1) && allDigits && (name[name.Length - 1] != '.'))
                return SymbolType.Terminal;

            // check terminal c) condition
            if ((name.Length == 1) && (!char.IsLetterOrDigit(name[0])))
                return SymbolType.Terminal;

            // check terminal a) condition (= epsilon condition)
            if (allLetDig && (char.IsLower(name[0]) || char.IsDigit(name[0])))
                return SymbolType.Epsilon | SymbolType.Terminal;

            // check nonterminal condition
            if (allLetDigEx && anyLetter && (char.IsUpper(name[0]) || ("@_".IndexOf(name[0]) != -1)))
                return SymbolType.Nonterminal;

            // no condition holds, give up
            return SymbolType.None;
        }

        //--[  Properties  ]---------------------------------------------------
        
        public string Name { get; protected set; }        
        
        public SymbolType Type { get; protected set; }

        public bool IsEpsilon { get { return Type == SymbolType.Epsilon; } }

        public Token Token { get; protected set; }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  Object       ]

        public override bool Equals(object obj)
        {
            Symbol other = obj as Symbol;
            return other == null ? false : Equals(other);
        }

        public override int GetHashCode()
        { return Name.GetHashCode(); }

        public override string ToString()
        {
            var src = Token == null ? Name : Token.Value;

            return ((src.Length == 1) 
                && !char.IsLetterOrDigit(src[0]) 
                && (Defaults.alphastr.IndexOf(src[0]) == -1))
                ? "'" + src.ToString() + "'" : src.ToString();
        }

        #endregion

        //--[  Interface implementation  ]-------------------------------------

        #region [  IEquatable   ]

        public bool Equals(Symbol other)
        { return (other != null) && Name.Equals(other.Name); }

        #endregion

        #region [  IComparable  ]

        public int CompareTo(Symbol other)
        { return Name.CompareTo(other.Name); }

        #endregion

    }
}