Analyser.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.Diagnostics;
using System.Linq;

namespace Mercury
{
//=============================================================================
//  Analyser
//=============================================================================

    public class Analyser<T, TResult> 
        where T       : class
        where TResult : class
    {
        private Func<T, TResult>           rselect;

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

        public Analyser(LanguageInfo<T> langinfo, Func<T,TResult> resultSelector,
                        IInterpreterContextFactory contextFactory = null)
            : this(langinfo.Tokenizer, langinfo.Scanner, new ChartParser(langinfo.Grammar), 
                   langinfo.RewriteRules == null ? null : new Interpreter<T>(langinfo.RewriteRules, contextFactory), 
                   resultSelector)
        { }

        public Analyser(ITokenizer      tokenizer,   IScanner scanner,          IParser parser, 
                        IInterpreter<T> interpreter, Func<T,TResult> resultSelector)
        {
            if (tokenizer == null) throw new ArgumentNullException("tokenizer");
            if (parser    == null) throw new ArgumentNullException("parser");

            if (interpreter != null && (resultSelector == null))
                throw new ArgumentNullException("resultSelector");

            Tokenizer      = tokenizer;
            Scanner        = scanner;
            Parser         = parser;
            Interpreter    = interpreter;

            this.rselect   = resultSelector;
        }

        //--[  Properties  ]---------------------------------------------------

        public ITokenizer      Tokenizer   { get; private set; }

        public IScanner        Scanner     { get; private set; }

        public IParser         Parser      { get; private set; }

        public IInterpreter<T> Interpreter { get; private set; }

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

        public AnalyserResult<T, TResult> Analyze(string input)
        {
            if (input == null)
                throw new ArgumentNullException("Null input? What am I supposed to do with that?");

            var result = new AnalyserResult<T, TResult>();

            IList<Token> tokens = null;
            var rules   = new List<Rule>();
            var watch   = new Stopwatch();

            // Ready... Steady... GO!
            watch.Start();

            //--<  Tokenizer stage  >------------------------------------------
            try 
            { tokens = Tokenizer.Tokenize(input); }
            catch (Exception ex)
            { 
                watch.Stop(); 
                result.SetStatus(watch.Elapsed, AnalyserStatus.TokenizerFail, ex: ex); 
                return result;
            }

            //--<  Scanner stage  >--------------------------------------------
            if (Scanner != null)
            try
            { rules.AddRange(Scanner.Scan(tokens)); }
            catch (Exception ex)
            { 
                watch.Stop(); 
                result.SetStatus(watch.Elapsed, AnalyserStatus.ScannerFail, ex: ex); 
                return result;
            }

            //--<  Parser stage  >---------------------------------------------
            try
            {
                result.ParserTime   = watch.Elapsed;
                result.ParserResult = Parser.Parse(tokens, rules);
                result.ParserTime   = watch.Elapsed - result.ParserTime;
            }
            catch (Exception ex)
            {
                watch.Stop();
                result.SetStatus(watch.Elapsed, AnalyserStatus.ParserFail, ex: ex);
                return result;
            }

            if (!result.ParserResult.Accepted)
            {
                watch.Stop();
                result.SetStatus(watch.Elapsed, AnalyserStatus.ParserFail, FailReason.NoResult);
                return result;
            }

            //--<  Interpreter stage  >----------------------------------------
            if (Interpreter != null)
            try
            {
                var sw    = new Stopwatch();
                var ok    = false;

                sw.Start();
                result.InterpreterResults = Interpreter.Interpret(result.ParserResult.Trees);
                sw.Stop();

                var rvals = new TResult[result.InterpreterResults.Count];

                for (int ix = 0; ix < result.InterpreterResults.Count; ++ix )
                {
                    var b = result.InterpreterResults[ix].Success;
                    ok |= b;
                    rvals[ix] = b ? rselect(result.InterpreterResults[ix].Result) : default(TResult);
                }

                result.Interpretations = rvals;
                result.InterpreterTime = sw.Elapsed;

                if (!ok)
                {
                    watch.Stop();
                    result.SetStatus(watch.Elapsed, AnalyserStatus.InterpreterFail, FailReason.NoResult);
                    return result;
                }

            }
            catch(Exception ex)
            {
                watch.Stop();
                result.SetStatus(watch.Elapsed, AnalyserStatus.InterpreterFail, ex: ex);
                return result;
            }


            //--<  Finalization  >---------------------------------------------
            watch.Stop();
            result.SetStatus(watch.Elapsed, AnalyserStatus.Success, FailReason.None);

            return result;
        }
    }

    public class Analyser<T> : Analyser<T,T> where T : class
    {
        public Analyser(LanguageInfo<T> langinfo, IInterpreterContextFactory contextFactory = null)
            : base(langinfo, x => x, contextFactory)
        { }

        public Analyser(ITokenizer tokenizer, IScanner scanner, IParser parser, IInterpreter<T> interpreter)
            : base(tokenizer, scanner, parser, interpreter, x => x)
        { }
    }

}