RewriteRulesFileParser.cs

Go to the documentation of this file.

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

namespace Mercury.Formats.Basic
{
    public class RewriteRulesParser<T> : IDisposable
        where T : class
    {
        private static Tokenizer inputTokenizer = null;

        //--[  Private fields  ]-----------------------------------------------

        private StreamReader source   = null;
        private string       filename = null;
        private Symbol       epsilon;

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

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

        public RewriteRulesParser(StreamReader reader,  Symbol epsilon, 
            IEnumerable<InterpreterAction<T>> actions, IReadOnlyDictionary<string,string> aliases = null)
        {
            if (reader  == null) throw new ArgumentNullException("reader");
            if (actions == null) throw new ArgumentNullException("actions");

            this.source  = reader;
            this.epsilon = epsilon;

            this.actions = actions.ToDictionary(x => x.Name, StringComparer.OrdinalIgnoreCase);
            this.aliases = aliases ?? new Dictionary<string, string>();

            var keywords = new[] { "==>" }.Concat(this.aliases.Select(x => x.Key));

            inputTokenizer = new Tokenizer("@_", keywords, TokenizerOptions.CompiledMatch);
        }

        public RewriteRulesParser(string filename, Symbol epsilon,
            IEnumerable<InterpreterAction<T>> actions, IReadOnlyDictionary<string, string> aliases = null)
            : this(new StreamReader(filename), epsilon, actions, aliases)
        { this.filename = filename; }

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

        private RewriteRuleCollection<T> GetRules(ref int linenum)
        {
            string line    = null;

            var tokens  = new List<Token>();
            var ruletok = new List<Token>();
            var builder = new RewriteRuleCollectionBuilder<T>();

            var iep = new InterpreterEntityParser<T>(epsilon, actions, aliases);

            Action parse = delegate()
            {
                if (ruletok.Count != 0) 
                    builder.AddRewriteRule(iep.ParseRewriteRule(ruletok));
                ruletok.Clear();
            };

            int actline = 0;
                linenum = 1;
            while((line = source.ReadLine()) != null)
            {
                ++actline;
                tokens.Clear();
                tokens.AddRange(inputTokenizer.Tokenize(line));
                
                if ((tokens.Count == 0) || (tokens[0].Value == "#"))
                    continue;

                if (tokens.Any(x => (x.Type == TokenType.Keyword) && (x.Value == "==>")))
                {
                    parse.Invoke();
                    ruletok.Clear();
                    linenum = actline;
                }

                ruletok.AddRange(tokens);
            }

            if (ruletok.Count != 0)
                parse.Invoke();

            return builder.GetCollection();
        }

        public RewriteRuleCollection<T> GetRules()
        {
            int linenum = 0;

            try
            { return GetRules(ref linenum); }
            catch (Exception ex)
            {
                string msg = filename == null
                    ? string.Format("In {0}: {1}",                    linenum, ex.Message)
                    : string.Format("In {0} line {1}: {2}", filename, linenum, ex.Message);

                throw new FormatException(msg, ex);
            }
        }

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

        #region [  IDisposable  ]

        public void Dispose()
        { if (filename != null) source.Close(); }

        #endregion

    }
}