Scanner.cs

Go to the documentation of this file.

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

namespace Mercury.Syntax
{
//=============================================================================
//  IScanner
//=============================================================================

    public interface IScanner
    {
        IEnumerable<Rule> Scan(IEnumerable<Token> tokens);
    }

//=============================================================================
//  CompositeScanner
//=============================================================================

    public class CompositeScanner : IScanner, IEnumerable<IScanner>
    {
        //--[  Private fields  ]-----------------------------------------------

        private List<IScanner> scanners;

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

        public CompositeScanner()
        { scanners = new List<IScanner>(); }

        public CompositeScanner(IEnumerable<IScanner> scanners)
            : this()
        { foreach (var scanner in scanners) Add(scanner); }

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

        public IScanner Add(IScanner scanner)
        {
            if (scanners.Contains(scanner)) return this;

            scanners.Add(scanner);
            return this;
        }

        public IScanner Remove(IScanner scanner)
        {
            scanners.Remove(scanner);
            return this;
        }

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

        #region[  IScanner     ]

        public IEnumerable<Rule> Scan(IEnumerable<Token> tokens)
        { return scanners.Select(scanner => scanner.Scan(tokens)).Aggregate((x, y) => x.Concat(y)); }

        #endregion

        #region [  IEnumerable  ]

        public IEnumerator<IScanner> GetEnumerator() { return scanners.GetEnumerator(); }

        IEnumerator IEnumerable.GetEnumerator()      { return scanners.GetEnumerator(); }

        #endregion

    }

//=============================================================================
//  BasicScannerMap
//=============================================================================

    [Flags]
    public enum Mapping
    {
        None      =  0,
        AsSymbol  =  1,
        AsKeyword =  2,
        AsNumber  =  4,
        AsString  =  8,
        All       = 15,
    };

    public class BasicScannerMap
    {
        //--[  Private fields  ]-----------------------------------------------

        private IDictionary<TokenType, Mapping> map;

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

        public BasicScannerMap(IDictionary<TokenType, Mapping> map)
        {
            if (map == null) throw new ArgumentNullException("map");

            this.map = map;
        }

        //--[  Static methods  ]-----------------------------------------------

        #region  [  Predefined maps  ]

        public static BasicScannerMap Identity
        { get { return new BasicScannerMap(new Dictionary<TokenType, Mapping> {
            { TokenType.Symbol,  Mapping.AsSymbol  },
            { TokenType.Number,  Mapping.AsNumber  },
            { TokenType.Keyword, Mapping.AsKeyword },
            { TokenType.String,  Mapping.AsString  },
        }); } }

        public static BasicScannerMap NumberOrString
        { get { return new BasicScannerMap(new Dictionary<TokenType, Mapping> {
            { TokenType.Symbol,  Mapping.AsString },
            { TokenType.Number,  Mapping.AsNumber },
            { TokenType.Keyword, Mapping.AsString },
            { TokenType.String,  Mapping.AsString },
        }); } }

        public static BasicScannerMap All
        { get { return new BasicScannerMap(new Dictionary<TokenType, Mapping> {
            { TokenType.Symbol,  Mapping.All },
            { TokenType.Number,  Mapping.All },
            { TokenType.Keyword, Mapping.All },
            { TokenType.String,  Mapping.All },
        }); } }

        public static BasicScannerMap SingleMap(Mapping custom)
        { return new BasicScannerMap(new Dictionary<TokenType, Mapping> {
            { TokenType.Symbol,  custom },
            { TokenType.Number,  custom },
            { TokenType.Keyword, custom },
            { TokenType.String,  custom },
        }); }

        #endregion

        //--[  Indexer  ]------------------------------------------------------

        public Mapping this[TokenType ttype] { get { return GetMapping(ttype); } }

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

        public Mapping GetMapping(TokenType ttype)
        {
            Mapping mapping;
            if (map.TryGetValue(ttype, out mapping))
                return mapping;

            return Mapping.None;
        }

    }

//=============================================================================
//  BasicScanner
//=============================================================================

    public class BasicScanner : IScanner
    {
        //--[  Private fields  ]-----------------------------------------------

        private BasicScannerMap map;

        private Rule MakeRule(string lhs, Token rhs)
        { return new Rule(new Symbol(lhs), new[] { new Symbol(rhs) }); }

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

        public BasicScanner(BasicScannerMap map)
        {
            if (map == null) throw new ArgumentNullException("map");

            this.map = map;
        }

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

        #region [  IScanner  ]

        public IEnumerable<Rule> Scan(IEnumerable<Token> tokens)
        {
            foreach(Token token in tokens)
            {
                Mapping mapping = map[token.Type];

                if (mapping.HasFlag(Mapping.AsKeyword)) yield return MakeRule("@Keyword", token);
                if (mapping.HasFlag(Mapping.AsNumber))  yield return MakeRule("@Number",  token);
                if (mapping.HasFlag(Mapping.AsString))  yield return MakeRule("@String",  token);
                if (mapping.HasFlag(Mapping.AsSymbol))  yield return MakeRule("@Symbol",  token);
            }
        }

        #endregion

    }
}