Un mini lexer à partir de votre enumération

Soyez le premier à donner votre avis sur cette source.

Snippet vu 9 515 fois - Téléchargée 29 fois

Contenu du snippet

cette classe "parse" votre texte pour le rendre sous forme de "TOKEN".
les TOKENs sont représentés par une enumération. à chaque TOKEN est associé un motif, ainsi lorsque qu'un motif est trouvé dans le texte son token est retourné.

Source / Exemple :


#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;
			}
		}
	}
}

Conclusion :


voici une exemple d'utilisation

enum TokenRules {LBRACE, RBRACE, IDENT, STRING, OR, SPACE}
MiniLexer tkRules = new MiniLexer(typeof(TokenRules), "\\(", "\\)", "[A-Za-z]+[A-Za-z0-9_]*" , "'[^']*'", "\\|", " ");
tkRules.Text = "NUMBER '+' EXPRESSION";
while (!tkRules.Eof)
{
Console.WriteLine(tkRules.NextToken().ToString());
}

un autre exemple

enum Test {NUMBER, SPACE, PLUS, MOINS};
tkRules = new MiniLexer(typeof(Test), "[0-9]+", " ", "\\+", "-");
tkRules.Text = "456 + 89 - 3";
while (!tkRules.Eof)
{
Console.WriteLine(tkRules.NextToken().ToString());
}

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.