GrammarParser.cs

Go to the documentation of this file.

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

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

    public class GrammarParser : IDisposable
    {
        private static Tokenizer inputTokenizer 
            = new Tokenizer(new[] { '@', '_' }, new[] { "->", "root", "epsilon", "metagrammar" }, TokenizerOptions.CompiledMatch);

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

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

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

        public GrammarParser(StreamReader reader)
        {
            if (reader == null) throw new ArgumentNullException("reader");

            source = reader;
        }

        public GrammarParser(string filename)
            : this(new StreamReader(filename))
        {
            this.filename = filename;
        }

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

        private GrammarBuilder GetBuilder(ref int linenum)
        {
                   linenum = 0;
            string line    = null;

            List<Token> tokens  = new List<Token>();

            bool   header  = true;
            Symbol root    = null;
            Symbol epsilon = null;
            while (header && ((line = source.ReadLine()) != null))
            { 
                ++linenum;
                
                tokens.Clear();
                tokens.AddRange(inputTokenizer.Tokenize(line));

                if ((tokens.Count == 0) || (tokens[0].Value == "#"))
                    continue;

                if (tokens[0].Type != TokenType.Keyword)
                { header = false; break; }

                switch(tokens[0].Value)
                {
                    case "root":
                        if (root         != null) goto alreadyset;
                        if (tokens.Count !=    2) goto syntaxerr;

                        root = new Symbol(tokens[1].Value, SymbolType.Nonterminal);
                        break;

                    case "epsilon":
                        if (epsilon      != null) goto alreadyset;
                        if (tokens.Count !=    2) goto syntaxerr;

                        epsilon = new Symbol(tokens[1].Value, SymbolType.Epsilon);
                        break;

                    alreadyset: throw new FormatException(string.Format("'{0}' option is already set", tokens[0].Value));
                    syntaxerr:  throw new FormatException(string.Format("Invalid syntax of '{0}'", tokens[0].Value));

                    default:
                        header = false;
                        break;
                }
            }

            GrammarBuilder builder= new GrammarBuilder(
                root    ?? new Symbol(Defaults.Root), 
                epsilon ?? new Symbol(Defaults.Epsilon, SymbolType.Epsilon));

            List<Token>         ruletok = new List<Token>();
            GrammarEntityParser gep     = new GrammarEntityParser(builder.Epsilon);

            Action parse = delegate() 
            { 
                if (ruletok.Count != 0) 
                    foreach (var rule in gep.ParseMultiRule(ruletok)) builder.AddRule(rule); 
                ruletok.Clear(); 
            };

            while(line != null)
            {
                if ((tokens.Count != 0) && (tokens[0].Value != "#"))
                {
                    if (tokens[0].Value != "|")
                        parse.Invoke();

                    ruletok.AddRange(tokens);
                }

                ++linenum;
                tokens.Clear();
                line = source.ReadLine();

                if (line == null)
                    parse.Invoke();
                else
                    tokens.AddRange(inputTokenizer.Tokenize(line));
            }

            return builder;
        }

        public GrammarBuilder GetBuilder()
        {
            int linenum = 0;

            try
            {
                return GetBuilder(ref linenum);
            }
            catch (Exception ex)
            {
                string msg = filename == null
                    ? string.Format("In line {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

    }
}