UN MINI LEXER À PARTIR DE VOTRE ENUMÉRATION

#region Imports
using System;
using System.Collections;
using System.Text.RegularExpressions;
#endregion

namespace Lexer
{
	/// <summary>
	/// mini lexer basé sur Regex
	/// </summary>
	public class MiniLexer
	{
		#region Variables
		private int				FCurPos;
		private Object		FCurToken;
		private string[]	FPatterns;
		private Regex[]		FRegExs;
		private string		FText;
		private string		FTokenString;
		private Type			FType;
		private ArrayList	FValues;
		#endregion

		/// <summary>
		/// constructeur 
		/// </summary>
		/// <param name="enumType">le type enum utiliser pour les tokens</param>
		/// <param name="patterns">la liste des partterns, un par enum</param>
		public MiniLexer(Type enumType, params string[] patterns)
		{
			if (enumType == null)
				throw new ArgumentNullException("enumType", "ce paramètre doit être != null");
			if (patterns == null)
				throw new ArgumentNullException("patterns", "ce paramètre doit être != null");
			if (!enumType.IsEnum)
				throw new ArgumentException("cet argument doit être un enum", "enumType");
		
			if (Enum.GetNames(enumType).Length != patterns.Length)
				throw new Exception("enumType.Length != patterns.Length !");

			FType = enumType;
			FPatterns = patterns;
			FValues = new ArrayList(Enum.GetValues(FType));
			int i = 0;
			//init des patterns
			FRegExs = new Regex[FPatterns.Length];
			foreach(string s in FPatterns)
			{
				FRegExs[i] = new Regex(s);
				i++;
			}
		}
		/// <summary>
		/// provoque la lecture du prochain token
		/// </summary>
		/// <returns>retourne la valeur d'un token, null si aucun token ne correspond au texte</returns>
		public Object NextToken()
		{
			int i;
			int maxlen, index;

			index = -1;
			maxlen = -1;
			for(i = 0; i < FRegExs.Length; i++)
			{
				Regex r = FRegExs[i];
				Match m = r.Match(FText, FCurPos);
				//recherche du match le plus grand à la position FCurPos
				if (m.Success && m.Index == FCurPos && m.Length > maxlen)
				{
					index = i;
					maxlen = m.Length;
				}
			}
			if (index != -1)
			{
				FTokenString = FText.Substring(FCurPos, maxlen);
				FCurPos += maxlen;
				FCurToken = FValues[index];
			}
			else
				FCurToken = null;
			return FCurToken;
		}

		/// <summary>
		/// retourne la chaîne correspondant au token courant
		/// </summary>
		public string TokenString
		{
			get
			{
				return FTokenString;
			}
		}

		/// <summary>
		/// retourne le token courant
		/// </summary>
		public Object Token
		{
			get
			{
				return FCurToken;
			}
		}
		
		/// <summary>
		/// indique si on est à la fin du texte
		/// </summary>
		public bool Eof
		{
			get
			{
				return FCurPos >= FText.Length;
			}
		}

		/// <summary>
		/// le Texte à "lexer"
		/// </summary>
		public string Text
		{
			get
			{
				return FText;
			}
			set
			{
				FText = value;
				FCurPos = 0;
				FTokenString = string.Empty;
			}
		}
	}
}