using System;

using System.Collections.Generic;

using System.Linq;

​

namespace DotNetAsm

{

    /// <summary>

    /// A dictionary of reserved words.

    /// </summary>

    public class ReservedWords

    {

        #region Members

​

        HashSet<string> _values;

​

        Dictionary<string, HashSet<string>> _types;

​

        #endregion

​

        #region Constructor

​

        /// <summary>

        /// Instantiates a new <see cref="T:DotNetAsm.ReservedWords"/> class object.

        /// </summary>

        /// <param name="comparer">A <see cref="T:System.StringComparison"/> object to indicate whether

        /// to enforce case-sensitivity.</param>

        public ReservedWords(StringComparer comparer)

        {

            _types = new Dictionary<string, HashSet<string>>();

            Comparer = comparer;

            _values = new HashSet<string>(comparer);

        }

​

        /// <summary>

        /// Instantiates a new <see cref="T:DotNetAsm.ReservedWords"/> class object.

        /// </summary>

        public ReservedWords() :

            this(StringComparer.Ordinal)

        {

​

        }

​

        #endregion

​

        #region Methods

​

        /// <summary>

        /// Add a reserved word to a defined type.

        /// </summary>

        /// <param name="type">The defined type</param>

        /// <param name="word">The reserved word to include</param>

        /// <exception cref="T:System.Collections.Generic.KeyNotFoundException">System.Collections.Generic.KeyNotFoundException

        /// </exception>

        public void AddWord(string type, string word)

        {

            var t = _types[type];

            t.Add(word);

            _values.Add(word);

        }

​

        /// <summary>

        /// Defie a type of reserved words.

        /// </summary>

        /// <param name="type">The type name.</param>

        /// <exception cref="T:System.ArgumentException">System.ArgumentException</exception>

        public void DefineType(string type) => _types.Add(type, new HashSet<string>());

​

        /// <summary>

        /// Define a type of reserved words.

        /// </summary>

        /// <param name="type">The type name.</param>

        /// <param name="values">The collection of values that comprise the type. </param>

        /// <exception cref="T:System.ArgumentNullException">System.ArgumentNullException</exception>

        /// <exception cref="T:System.ArgumentException">System.ArgumentException</exception>

        public void DefineType(string type, params string[] values)

        {

            _types.Add(type, new HashSet<string>(values));

            foreach (var v in values)

                _values.Add(v); // grr!!!

        }

​

        /// <summary>

        /// Determines if the token is one of the type specified.

        /// </summary>

        /// <param name="token">The token or keyword.</param>

        /// <param name="type">The type (dictionary key).</param>

        /// <returns><c>True</c> if the specified token is one of the specified type, otherwise <c>false</c>.</returns>

        /// <exception cref="T:System.ArgumentNullException">System.ArgumentNullException</exception>

        /// <exception cref="T:System.ArgumentException">System.ArgumentException</exception>

        public bool IsOneOf(string token, string type) => _types[type].Any(d => d.Equals(token));

        /// <summary>

        /// Determines if the token is one of the types specified.

        /// </summary>

        /// <param name="token">The token or keyword.</param>

        /// <param name="type">The types (dictionary keys).</param>

        /// <returns><c>True</c> if the specified token is one of the specified types, otherwise <c>false</c>.</returns>

        /// <exception cref="T:System.ArgumentNullException">System.ArgumentNullException</exception>

        /// <exception cref="T:System.ArgumentException">System.ArgumentException</exception>

        public bool IsOneOf(string token, params string[] types)

        {

            return _types.Where(k => types.ToList().Contains(k.Key)).Any(v => v.Value.Contains(token));

        }

​

        /// <summary>

        /// Determines if the token is in the list of reserved words for all types.

        /// </summary>

        /// <param name="token">The token or keyword.</param>

        /// <returns><c>True</c> if the specified token is in the collection of reserved words,

        /// regardless of type, otherwise <c>false</c>.</returns>

        public bool IsReserved(string token) => _values.Any(s => s.Equals(token));

​

        /// <summary>

        /// Gets the type of the token, if any.

        /// </summary>

        /// <param name="token">The token or keyword.</param>

        /// <returns>The type of the token.</returns>

        public string GetType(string token)

        {

            return _types.FirstOrDefault(kv => kv.Value.Equals(token)).Key;

        }

​

        /// <summary>

        /// Determines if the ReservedWord object contains a type (key) of reserved words.

        /// </summary>

        /// <param name="type">The type to check.</param>

        /// <returns><c>True</c> if the <see cref="T:DotNetAsm.ReservedWord"/> object has the type, 

        /// otherwise <c>false</c>.</returns>

        public bool HasType(string type) => _types.ContainsKey(type);

​

        #endregion

​

        #region Properties

​

        /// <summary>

        /// Gets or sets the <see cref="T:System.StringComparer"/> for the 

        /// <see cref="T:DotNetAsm.ReservedWords"/> collection.

        /// </summary>

        public StringComparer Comparer { get; set; }

​

        #endregion

    }

}

public class Program

{

    static DotNetAsm.ReservedWords Reserved = new DotNetAsm.ReservedWords(StringComparer.OrdinalIgnoreCase);

    public static void Main()

    {

        string token = "lda";

        string type = "6502";

        string[] cpu65816 = { "65816", "65C02", "6502" };

        Reserved.DefineType("65816", "mvp", "sep", "rep", "jml");

        Reserved.DefineType("65C02", "bra", "phx", "phy");

        Reserved.DefineType("6502i", "isb", "jam");

        Reserved.DefineType("6502", "lda", "and", "ora", "brk");

        Console.WriteLine("Is \"{0}\" one of \"{1}\"? {2}", token, type, Reserved.IsOneOf(token, type));

        Console.WriteLine("Is \"{0}\" one of \"{1}\"? {2}", token, string.Join(",", cpu65816), Reserved.IsOneOf(token, cpu65816));

    }

}