ModuleLoader.cs

Go to the documentation of this file.

using Mercury.Formats.Basic;
using Mercury.Interpreting;
using Mercury.Scanning;
using Mercury.Syntax;
using System.Collections.Generic;
using System.IO;

//
//   EXPERIMENTAL
//   ============
//
//   Do not use. For your own safety. 
//   Might set your keyboard on fire or whatnot.
// 

namespace Mercury.Experimental
{
    internal class GrammarLoaderInternal<T> where T : class
    {
        private string  grammarcwd;
        private Grammar grammar;

        private IList<InterpreterAction<T>> actions;

        private IScanner GetScanner()
        {
            List<IScanner> scanners = new List<IScanner>();
            /*
            if (GrammarInfo.UseMercuryScanner) scanners.Add(new BasicScanner(BasicScannerMap.Identity));

            var libdata = GrammarInfo.Scanners.ToMultiDictionary(x => x.Key, x => x.Value);
            foreach(var libname in libdata.Keys)
            {
                Assembly lib = Assembly.Load(Path.Combine(grammarcwd, libname));
                foreach(var objname in libdata[libname])
                {
                    Type objtype = lib.GetType(objname);
                    var  scanner = (IScanner) Activator.CreateInstance(objtype);

                    if (scanner == null)
                        throw new InvalidOperationException(string.Format("'{0}' is not a scanner", objtype.Name));

                    scanners.Add(scanner);
                }
            }
            */
            return scanners.Count == 1 ? scanners[0] : new CompositeScanner(scanners);
        }

        private Grammar GetGrammar()
        {
            var gb = new GrammarBuilder(new Symbol(GrammarInfo.Root), new Symbol(GrammarInfo.Epsilon, SymbolType.Epsilon));

            foreach(var gname in GrammarInfo.GrammarFiles)
            {
                var gparser = new GrammarParser(Path.Combine(GrammarInfo.Path, gname));
                gb.Include(gparser.GetBuilder());
            }

            return gb.GetGrammar();
        }

        private IList<InterpreterAction<T>> GetActions()
        {
            var actions = new List<InterpreterAction<T>>() {  };
            /*
            if (GrammarInfo.UseStringActions)
            {
                actions.Add((IInterpreterAction<T>) new ConstantAction()   ); 
                actions.Add((IInterpreterAction<T>) new PreterminalAction()); 
                actions.Add((IInterpreterAction<T>) new SimpleAction()     );
            }

            var libdata = GrammarInfo.Actions.ToMultiDictionary(x => x.Key, x => x.Value);
            foreach (var libname in libdata.Keys)
            {
                Assembly lib = Assembly.Load(Path.Combine(grammarcwd, libname));
                foreach (var objname in libdata[libname])
                {
                    Type objtype = lib.GetType(objname);
                    var  action  = (IInterpreterAction<T>)Activator.CreateInstance(objtype);

                    if (action == null)
                        throw new InvalidOperationException(string.Format("'{0}' is not a valid action of type '{1}'", objtype.Name, typeof(T).Name));

                    actions.Add(action);
                }
            }
            */
            return actions;
        }

        private RewriteRuleCollection<T> GetRwRules()
        {
            var rwrb = new RewriteRuleCollectionBuilder<T>();

            foreach (var rwrname in GrammarInfo.RwRulesFiles)
            {
                var iparser = new RewriteRulesParser<T>(rwrname, new Symbol(GrammarInfo.Epsilon, SymbolType.Epsilon), actions);
                rwrb.AddRules(iparser.GetRules());
            }

            return rwrb.GetCollection();
        }

        public GrammarLoaderInternal(GrammarInfo grminf)
        {
            this.GrammarInfo = grminf;
            this.grammarcwd  = grminf.Path;
        }

        public LanguageInfo<T> GetLanguageInfo()
        {
            grammar = GetGrammar();
            actions = GetActions();
            return new LanguageInfo<T>(GrammarInfo.Name, new Tokenizer(), GetScanner(), grammar, GetRwRules());
        }

        public  GrammarInfo GrammarInfo { get; private set; }
    }

    internal static class GrammarLoader<T> where T : class
    {
        public static LanguageInfo<T> GetLanguageInfo(GrammarInfo grminf)
        { return (new GrammarLoaderInternal<T>(grminf)).GetLanguageInfo(); }

        public static LanguageInfo<T> GetLanguageInfo(string file)
        { return GetLanguageInfo(GrammarInfo.FromXML(file)); }

        public static Analyser<T> GetAnalyzer(GrammarInfo grminf)
        { return new Analyser<T>(new GrammarLoaderInternal<T>(grminf).GetLanguageInfo()); }

        public static Analyser<T> GetAnalyzer(string file)
        { return GetAnalyzer(GrammarInfo.FromXML(file)); }
    }
}