protected QuantifierToken(QuantifierType type, bool isLazy)
{
Type = type;
IsLazy = isLazy;
switch (type)
{
case QuantifierType.Optional:
TokenType = IsLazy ? RegexTokenType.LazyOptionalQuantifier : RegexTokenType.GreedyOptionalQuantifier;
break;
case QuantifierType.OptionalRepeat:
TokenType = IsLazy ? RegexTokenType.LazyOptionalRepeatQuantifier : RegexTokenType.GreedyOptionalRepeatQuantifier;
break;
case QuantifierType.Multiple:
TokenType = IsLazy ? RegexTokenType.LazyMultipleQuantifier : RegexTokenType.GreedyMultipleQuantifier;
break;
case QuantifierType.Fixed:
TokenType = IsLazy ? RegexTokenType.LazyFixedQuantifier : RegexTokenType.GreedyFixedQuantifier;
break;
case QuantifierType.MinRepeat:
TokenType = IsLazy ? RegexTokenType.LazyMinRepeatQuantifier : RegexTokenType.GreedyMinRepeatQuantifier;
break;
default:
TokenType = IsLazy ? RegexTokenType.LazyLimitedQuantifier : RegexTokenType.GreedyLimitedQuantifier;
break;
}
}
public OpenGroupToken(RegexTokenType tokenType, int depth, char precedingChar1, char precedingChar2, char precedingChar3, string name, params char[] followingValues)
{
_tokenType = tokenType;
_depth = depth;
_precedingValues = new char[] { precedingChar1, precedingChar2, precedingChar3 };
_name = (name == null) ? string.Empty : name;
_followingValues = (followingValues == null) ? Array.Empty <char>() : followingValues;
}
public OpenGroupToken(RegexTokenType tokenType, int depth, string precedingChars, string name, params char[] followingValues)
{
_tokenType = tokenType;
_depth = depth;
_precedingValues = new char[] { '?' }.Concat(precedingChars).ToArray();
_name = (name == null) ? string.Empty : name;
_followingValues = (followingValues == null) ? Array.Empty <char>() : followingValues;
}
public CharTokens(RegexTokenType tokenType, string value)
{
if (string.IsNullOrEmpty(value))
{
throw new ArgumentException("Value cannot be empty", "value");
}
_tokenType = tokenType;
_values = value.ToCharArray();
}
public CharTokens(RegexTokenType tokenType, params char[] values)
{
if (values == null || values.Length < 1)
{
throw new ArgumentException("At least one character must be provided", "values");
}
_tokenType = tokenType;
_values = values;
}
private bool Match(RegexTokenType tokenType)
{
if (_currentToken.TokenType == tokenType)
{
NextToken();
return(true);
}
else
{
return(false);
}
}
public NamedToken(RegexTokenType tokenType, IList <char> precedingValues, string name, params char[] followingValues)
{
if (precedingValues == null || precedingValues.Count < 1)
{
throw new ArgumentException("At least one preceding character must be provided", "precedingValues");
}
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("Name cannot be empty", "name");
}
if (followingValues == null || followingValues.Length < 1)
{
throw new ArgumentException("At least one following character must be provided", "followingValues");
}
_tokenType = tokenType;
_precedingValues = precedingValues;
_name = name;
_followingValues = followingValues;
}
private IParseResult <ExpressionMetaData> TryGetSubExpressionList(RegexTokenType token, ITokenStream tokenStream, out List <IExpression> subExpressionList)
{
subExpressionList = null;
var subExpressionResult = _regexTokenToExpressionListMapper[token](tokenStream, out var subExpression);
if (!subExpressionResult.IsSuccess)
{
return(subExpressionResult);
}
subExpressionList = new List <IExpression> {
subExpression
};
var nextToken = tokenStream.LookAhead(0).GetType <RegexTokenType>();
var metaData = subExpressionResult.Value;
while (nextToken == token)
{
if (token == RegexTokenType.Intersection)
{
metaData.HasIntersection = true;
}
tokenStream.Pop();
subExpressionResult = _regexTokenToExpressionListMapper[token](tokenStream, out subExpression);
if (!subExpressionResult.IsSuccess)
{
return(subExpressionResult);
}
metaData.UpdateWith(subExpressionResult.Value);
subExpressionList.Add(subExpression);
nextToken = tokenStream.LookAhead(0).GetType <RegexTokenType>();
}
return(new SuccessParseResult <ExpressionMetaData>(tokenStream.CurrentPosition, metaData));
}
private RegexExpression ExpressionSeq()
{
var expressionStack = new Stack <RegexExpression>();
while (true)
{
if (_currentToken.Lexeme == null ||
_currentToken.TokenType == RegexTokenType.RightParenthesis ||
_currentToken.TokenType == RegexTokenType.RightBracket)
{
break;
}
else if (expressionStack.Count > 0)
{
RegexTokenType opType = RegexTokenType.None;
if (_currentToken.TokenType == RegexTokenType.OrOperator)
{
opType = RegexTokenType.OrOperator;
NextToken();
}
expressionStack.Push(new OperatorExpression(opType));
}
expressionStack.Push(Expression());
}
var lastExp = expressionStack.Pop();
while (expressionStack.Count > 0)
{
var op = expressionStack.Pop() as OperatorExpression;
lastExp = new BinaryExpression(expressionStack.Pop(), op.Type, lastExp);
}
return(lastExp);
}
public OperatorExpression(RegexTokenType type)
{
Type = type;
}
private bool Match(RegexTokenType tokenType)
{
if (_currentToken.TokenType == tokenType)
{
NextToken();
return true;
}
else
{
return false;
}
}
public BinaryExpression(RegexExpression left, RegexTokenType op, RegexExpression right)
{
Left = left;
Operator = op;
Right = right;
}
public CloseGroupToken(RegexTokenType tokenType, int depth)
{
_tokenType = tokenType;
_depth = depth;
}
public RegexToken(RegexTokenType tokenType, string lexeme, int index)
{
TokenType = tokenType;
Lexeme = lexeme;
Index = index;
}
public RegexToken(RegexTokenType tokenType, string lexeme, int index)
{
TokenType = tokenType;
Lexeme = lexeme;
Index = index;
}
public BinaryExpression(RegexExpression left, RegexTokenType op, RegexExpression right)
{
Left = left;
Operator = op;
Right = right;
}
public OperatorExpression(RegexTokenType type)
{
Type = type;
}
