EntityParser.cs

Go to the documentation of this file.

using Mercury;
using Mercury.Scanning;
using Mercury.Interpreting;
using Mercury.Syntax;
using System;
using System.Collections.Generic;
using System.Linq;

namespace Mercury.Formats.Basic
{
//=============================================================================
//  GrammarEntityParser
//=============================================================================

    public class GrammarEntityParser
    {

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

        public GrammarEntityParser(Symbol epsilon)
        {
            if (epsilon == null || epsilon.Type != SymbolType.Epsilon)
                throw new ArgumentException("Required epsilon symbol for Grammar Entity Parser");

            Epsilon = epsilon;
        }

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

        public Symbol ParseSymbol(Token token)
        {
            FmtChk.AssertNotNull(token, "token");

            string sname = token.Value.Unescape();
            SymbolType stype = sname == Epsilon.Name ? SymbolType.Epsilon : SymbolType.Terminal | SymbolType.Nonterminal;

            return new Symbol(sname, stype);
        }

        public Rule ParseRule(IList<Token> tokens)
        {
            FmtChk.AssertNotNull(tokens, "tokens");
            FmtChk.AssertCount(3, tokens, "Not a rule");
            FmtChk.AssertToken(tokens[1], "->", "Operator '->' missing");

            Symbol lhs = ParseSymbol(tokens[0]);

            return new Rule(lhs, tokens.Skip(2).Select(x => ParseSymbol(x)));
        }

        public IList<Rule> ParseMultiRule(IList<Token> tokens)
        {
            FmtChk.AssertNotNull(tokens, "tokens");
            FmtChk.AssertCount(3, tokens, "Not a rule");

            var prefix = tokens.Take(2).ToArray();
            var rhs    = new List<Token>();
            var result = new List<Rule>();

            foreach(Token token in tokens.Skip(2))
                if (token.Value == "|")
                {
                    result.Add(ParseRule(prefix.Concat(rhs).ToList()));
                    rhs.Clear();
                }
                else
                    rhs.Add(token);

            result.Add(ParseRule(prefix.Concat(rhs).ToList()));
            return result;
        }

        public Edge ParseEdge(IList<Token> tokens)
        {
            FmtChk.AssertNotNull(tokens, "tokens");
            FmtChk.AssertCount(8, tokens, "Not an edge");            
            FmtChk.AssertPattern(new[] { "(", null, ",", null, ")", null, "->" }, tokens, x => x.Value);

            int l = int.Parse(tokens[1].Value);
            int r = int.Parse(tokens[3].Value);
            int d = -1;

            List<Token> lhs = new List<Token> { tokens[5], tokens[6] };
            List<Token> rhs = new List<Token>();

            for (int tokix = 7; tokix < tokens.Count; ++tokix)
                if (tokens[tokix].Value == ".")
                {
                    FmtChk.AssertTrue(d == -1, "Too many '.' markers in the edge");
                    d = tokix - 7;
                }
                else
                    rhs.Add(tokens[tokix]);

            if (rhs.Count == 0)
                rhs.Add(new Token(Epsilon.Name, TokenType.String, 0));

            FmtChk.AssertFalse(d == -1, "Edge mark '.' missing");

            return new Edge(ParseRule(lhs.Concat(rhs).ToList()), d, l, r);
        }

        public Symbol Epsilon { get; private set; }
    }

//=============================================================================
//  InterpreterEntityParser
//=============================================================================

    public class InterpreterEntityParser<T> where T : class
    {
        //--[  Internals  ]----------------------------------------------------

        internal class AlternativeData
        {
            public AlternativeData()
            {
                WildcardSymbols = SymbolType.None;
                Symbols         = new List<Symbol>();
            }

            public SymbolType    WildcardSymbols { get; set; }
            public List<Symbol>  Symbols         { get; set; }
        }

        private GrammarEntityParser gep;
        private IReadOnlyDictionary<string, InterpreterAction<T>> actions;
        private IReadOnlyDictionary<string, string>               aliases;

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

        public InterpreterEntityParser(Symbol epsilon, 
            IReadOnlyDictionary<string, InterpreterAction<T>> actions, 
            IReadOnlyDictionary<string, string>               aliases)
        {
            this.gep     = new GrammarEntityParser(epsilon);
            this.actions = actions;
            this.aliases = aliases;
        }

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

        public IElement ParseElement(IList<Token> tokens, int start, out int end)
        {
            FmtChk.AssertNotNull(tokens, "tokens");
            FmtChk.AssertCount(start + 1, tokens);

            if (tokens[start].Quoted) return ParseConstant(tokens, start, out end);

            switch (tokens[start].Value)
            {
                case "?": end = start + 1;
                          return new Variable();
                case "#": return ParseVariable (tokens, start, out end);
                case "*": return ParseWildcard (tokens, start, out end);
                case "[": return ParseStructure(tokens, start, out end);
                default:  return ParseConstant (tokens, start, out end);
            }
        }

        public Constant ParseConstant(IList<Token> tokens, int start, out int end)
        {
            FmtChk.AssertNotNull(tokens, "tokens");
            FmtChk.AssertCount(start + 1, tokens, "Not a constant");

            List<Symbol> smlist = new List<Symbol>();
            SymbolType   mask   = SymbolType.None;
            while (tokens[start].Value != ":")
            {
                var name = tokens[start].Value.Unescape();
                if (name == gep.Epsilon.Name)
                    mask |= SymbolType.Epsilon;
                else
                    smlist.Add(new Symbol(name));

                if ((start + 2 < tokens.Count) 
                    && (tokens[start + 2].Value != "|") 
                    && (tokens[start + 1].Value == "|"))
                    start += 2;
                else
                {
                    ++start;
                    break;
                }
            }

            end = start;

            if ((start + 1 < tokens.Count) && (tokens[start].Value == ":"))
            {
                foreach(char c in tokens[start + 1].Value)
                {
                    switch (c)
                    {
                        case 'N': mask |= SymbolType.Nonterminal; break;
                        case 'T': mask |= SymbolType.Terminal;    break;
                        case 'e': mask |= SymbolType.Epsilon;     break;
                        default: throw new FormatException(string.Format("Unexpected flag {0} in an alternative", c));
                    }
                }
                end = start + 2;
            }

            return new Constant(mask, smlist);
        }

        public Variable ParseVariable(IList<Token> tokens, int start, out int end)
        {
            FmtChk.AssertNotNull(tokens, "tokens");
            FmtChk.AssertCount(start + 2, tokens, "Not a variable");
            FmtChk.AssertFalse(tokens[start].Quoted, "Not a variable");
            FmtChk.AssertToken(tokens[start], "#");

            if (tokens[start + 1].Position != tokens[start].Position + 1)
                throw new FormatException(string.Format("Name of variable expected at position {0}", tokens[start].Position + 1));

            var varname = tokens[start + 1].Value;
            end = start + 2;

            Constant cst = null;
            if ((start + 2 < tokens.Count) && (tokens[start + 2].Value == ":"))
                cst = ParseConstant(tokens, start + 3, out end);
            else
                cst = new Constant(SymbolType.Any, new Symbol[0]);

            return new Variable(varname, cst.SymbolMask, cst.Symbols);
        }

        public Wildcard ParseWildcard(IList<Token> tokens, int start, out int end)
        {
            FmtChk.AssertNotNull(tokens, "tokens");
            FmtChk.AssertCount(start + 1, tokens, "Not a wildcard");
            FmtChk.AssertFalse(tokens[start].Quoted, "Not a wildcard");
            FmtChk.AssertToken(tokens[start], "*");

            end = ++start;

            string name = null;
            if ((start < tokens.Count) && (tokens[start].Position == tokens[start - 1].Position + 1))
            {
                name = tokens[start].Value;
                ++start;
                ++end;
            }

            Constant cst = null;
            cst = ((start < tokens.Count) && (tokens[start].Value == ":"))
                ? ParseConstant(tokens, start + 1, out end)
                : new Constant(SymbolType.Any, new Symbol[0]);

            return new Wildcard(name, cst.SymbolMask, cst.Symbols);
        }

        public Structure ParseStructure(IList<Token> tokens, int start, out int end)
        {
            FmtChk.AssertNotNull(tokens, "tokens");
            FmtChk.AssertCount(start + 1, tokens, "Not a structure");
            FmtChk.AssertFalse(tokens[start].Quoted, "Not a structure");
            FmtChk.AssertToken(tokens[start], "[");

            List<IElement> elements = new List<IElement>();
            int ix = start + 1;
            while ((ix < tokens.Count) && (tokens[ix].Value != "]"))
                elements.Add(ParseElement(tokens, ix, out ix));

            end = ix + 1;
            FmtChk.AssertTrue(ix < tokens.Count, "Expected ']' at the end of strucutre");
            FmtChk.AssertNotEmpty(elements, "Empty structure is not valid");

            return new Structure(elements[0], elements.Skip(1));
        }

        public IFormalParameter ParseParameter(IList<Token> tokens, int start, out int end)
        {
            FmtChk.AssertNotNull(tokens, "tokens");
            FmtChk.AssertCount(start + 1, tokens, "Not a parameter");

            end = start + 1;
            if (tokens[start].Quoted)
                return ConstantParameter.StringParameter(tokens[start].Value.Unescape());

            switch (tokens[start].Value)
            {
                case "(": return ParseActionCall(tokens, start, out end);
                
                case "#":
                    FmtChk.AssertCount(start + 2, tokens);

                    end = start + 2;
                    return new VariableParameter(tokens[start + 1].Value);

                default:
                    end = start + 1;
                    return ConstantParameter.AutoCreate(tokens[start].Value.Unescape());
            }
        }

        public ActionCall<T> ParseActionCall(IList<Token> tokens, int start, out int end)
        {
            FmtChk.AssertNotNull(tokens, "tokens");
            FmtChk.AssertCount(start + 3, tokens, "Not an action");
            FmtChk.AssertFalse(tokens[start].Quoted, "Not an action");
            FmtChk.AssertToken(tokens[start], "(");

            string name = name = tokens[start + 1].Value;

            InterpreterAction<T> action;
            if (!actions.TryGetValue(name, out action))
            {
                string alias = null;
                if (!aliases.TryGetValue(name, out alias) || !actions.TryGetValue(alias, out action))
                    throw new FormatException(string.Format("Action '{0}' not found", name));
            }

            IFormalParameter[] fparams = ParseParameters(tokens, start + 2, out end);
            if (end >= tokens.Count || tokens[end].Value != ")")
                throw new ArgumentException("Expected ')' at the end of action call");
            ++end;

            return new ActionCall<T>(action, fparams);
        }

        public IFormalParameter[] ParseParameters(IList<Token> tokens, int start, out int end)
        {
            FmtChk.AssertNotNull(tokens, "tokens");
            FmtChk.AssertCount(start + 1, tokens, "No parameters");

            List<IFormalParameter> fparams = new List<IFormalParameter>();

            int fst = end = start;
            while ((start < tokens.Count) && (tokens[start].Quoted || (tokens[start].Value != ")")))
            {
                fparams.Add(ParseParameter(tokens, start, out end));
                start = end;
            };

            return fparams.ToArray();
        }

        public RewriteRule<T> ParseRewriteRule(IList<Token> tokens)
        {
            FmtChk.AssertNotNull(tokens, "tokens");
            FmtChk.AssertNotEmpty(tokens);

            int arrow = -1;
            for (int ix = 0; (arrow == -1) && (ix < tokens.Count); ++ix)
                if ((tokens[ix].Type == TokenType.Keyword) && (tokens[ix].Value == "==>"))
                    arrow = ix;

            int end;
            FmtChk.AssertTrue(arrow != -1, "Missing '==>' in rule");

            Structure lhs = ParseElement(tokens, 0, out end) as Structure;
            FmtChk.AssertNotNull(lhs,       "Missing LHS structure");
            FmtChk.AssertTrue(end == arrow, "Invalid LHS structure");

            ActionCall<T> rhs = ParseActionCall(tokens, arrow + 1, out end);
            if (end != tokens.Count) throw new ArgumentException(string.Format("Unexpected token '{0}' after action", tokens[end].Value));;

            return new RewriteRule<T>(lhs, rhs);
        }
    }
}