public override MatchContext Match(Token token, MatchContext context)
{
MatchContext newContext;
if (!(token is CommentLiteral))
{
string tokenText = token.TextValue;
if (token.Root.Language.IsCaseInsensitive)
{
TextSpan textSpan = caseInsensitiveRegex.Match(tokenText).GetTextSpan(tokenText);
if (!textSpan.IsZero)
{
newContext = context.AddMatch(token);
}
else
{
newContext = context.Fail();
}
}
else if (id.Equals(tokenText))
{
newContext = context.AddMatch(token);
}
else
{
newContext = context.Fail();
}
}
else
{
newContext = context.Fail();
}
return(newContext);
}
protected override MatchContext Match(Ust ust, MatchContext context)
{
if (ust is IntLiteral intLiteral)
{
return(MinValue <= intLiteral.Value && MaxValue > intLiteral.Value
? context.AddMatch(intLiteral)
: context.Fail());
}
if (ust is LongLiteral longLiteral)
{
return(MinValue <= longLiteral.Value && MaxValue > longLiteral.Value
? context.AddMatch(longLiteral)
: context.Fail());
}
if (ust is BigIntLiteral bigIntLiteral)
{
return(MinValue <= bigIntLiteral.Value && MaxValue > bigIntLiteral.Value
? context.AddMatch(bigIntLiteral)
: context.Fail());
}
if (context.UstConstantFolder != null &&
context.UstConstantFolder.TryGetOrFold(ust, out FoldResult foldingResult))
{
context.MatchedWithFolded = true;
if (foldingResult.Value is long longValue)
{
return(MinValue <= longValue && MaxValue > longValue
? context.AddMatches(foldingResult.TextSpans)
: context.Fail());
}
}
return(context.Fail());
}
protected override MatchContext Match(Ust ust, MatchContext context)
{
var idToken = ust as IdToken;
if (idToken == null)
{
return(context.Fail());
}
MatchContext newContext = context;
if (ust.Parent is AssignmentExpression parentAssignment &&
ReferenceEquals(idToken, parentAssignment.Left))
{
if (Value != null)
{
newContext = Value.MatchUst(idToken, newContext);
if (newContext.Success)
{
newContext.Vars[Id] = idToken;
}
}
else
{
newContext.Vars[Id] = idToken;
newContext = newContext.AddMatch(idToken);
}
}
public override MatchContext Match(Ust ust, MatchContext context)
{
MatchContext newContext = Pattern.MatchUst(ust, context);
return(newContext.Success
? newContext.Fail()
: newContext.AddMatch(ust));
}
public override MatchContext Match(ThrowStatement throwStatement, MatchContext context)
{
MatchContext newContext = Expression.MatchUst(throwStatement.ThrowExpression, context);
return(newContext.Success
? newContext.AddMatch(throwStatement)
: newContext.Fail());
}
public override MatchContext Match(ReturnStatement returnStatement, MatchContext context)
{
MatchContext newContext = Expression.MatchUst(returnStatement.Return, context);
return(newContext.Success
? newContext.AddMatch(returnStatement)
: newContext.Fail());
}
public override MatchContext Match(Ust ust, MatchContext context)
{
if (ust == null)
{
return(context.MakeSuccess());
}
return(context.AddMatch(ust));
}
protected override MatchContext Match(Ust ust, MatchContext context)
{
var baseReferenceToken = ust as BaseReferenceToken;
if (baseReferenceToken == null)
{
return(context.Fail());
}
return(context.AddMatch(ust));
}
protected override MatchContext Match(Ust ust, MatchContext context)
{
if (ust is TupleCreateExpression)
{
return(context.AddMatch(ust));
}
else
{
return(context.Fail());
}
}
protected override MatchContext Match(Ust ust, MatchContext context)
{
switch (ust)
{
case IntLiteral intLiteral:
return(Value == intLiteral.Value
? context.AddMatch(ust)
: context.Fail());
case LongLiteral longLiteral:
return(Value == longLiteral.Value
? context.AddMatch(ust)
: context.Fail());
case BigIntLiteral bigIntLiteral:
return(Value == bigIntLiteral.Value
? context.AddMatch(ust)
: context.Fail());
}
if (context.UstConstantFolder != null &&
context.UstConstantFolder.TryGetOrFold(ust, out FoldResult foldingResult))
{
context.MatchedWithFolded = true;
if (foldingResult.Value is int intValue)
{
return(Value == intValue?context.AddMatches(foldingResult.TextSpans) : context.Fail());
}
if (foldingResult.Value is long longValue)
{
return(Value == longValue?context.AddMatches(foldingResult.TextSpans) : context.Fail());
}
if (foldingResult.Value is BigInteger bigIntValue)
{
return(Value == bigIntValue?context.AddMatches(foldingResult.TextSpans) : context.Fail());
}
}
return(context.Fail());
}
protected override MatchContext Match(Ust ust, MatchContext context)
{
foreach (PatternUst pattern in Patterns)
{
context = pattern.MatchUst(ust, context);
if (!context.Success)
{
return(context.Fail());
}
}
return(context.AddMatch(ust));
}
protected override MatchContext Match(Ust ust, MatchContext context)
{
var booleanLiteral = ust as BooleanLiteral;
if (booleanLiteral == null)
{
return(context.Fail());
}
return((Boolean == null || Boolean.Value.Equals(booleanLiteral.Value))
? context.AddMatch(booleanLiteral)
: context.Fail());
}
protected override MatchContext Match(Ust ust, MatchContext context)
{
var binaryOperatorLiteral = ust as BinaryOperatorLiteral;
if (binaryOperatorLiteral == null)
{
return(context.Fail());
}
return(BinaryOperator.Equals(binaryOperatorLiteral.BinaryOperator)
? context.AddMatch(binaryOperatorLiteral)
: context.Fail());
}
public override MatchContext Match(Ust ust, MatchContext context)
{
MatchContext newContext = context;
foreach (PatternUst pattern in Patterns)
{
newContext = pattern.MatchUst(ust, newContext);
if (!newContext.Success)
{
return(newContext.Fail());
}
}
return(newContext.AddMatch(ust));
}
protected override MatchContext Match(Ust ust, MatchContext context)
{
var returnStatement = ust as ReturnStatement;
if (returnStatement == null)
{
return(context.Fail());
}
MatchContext newContext = Expression.MatchUst(returnStatement.Return, context);
return(newContext.Success
? newContext.AddMatch(returnStatement)
: newContext.Fail());
}
protected override MatchContext Match(Ust ust, MatchContext context)
{
if (ust is StringLiteral stringLiteral)
{
return(String.Equals(stringLiteral.Text) ? context.AddMatch(stringLiteral) : context.Fail());
}
if (context.UstConstantFolder != null &&
context.UstConstantFolder.TryGetOrFold(ust, out FoldResult foldingResult))
{
context.MatchedWithFolded = true;
if (foldingResult.Value is string stringValue)
{
return(String.Equals(stringValue) ? context.AddMatches(foldingResult.TextSpans) : context.Fail());
}
}
return(context.Fail());
}
public override MatchContext Match(IdToken idToken, MatchContext context)
{
MatchContext newContext;
newContext = context;
if (idToken.Parent is AssignmentExpression parentAssignment &&
ReferenceEquals(idToken, parentAssignment.Left))
{
if (Value != null)
{
newContext = Value.MatchUst(idToken, newContext);
if (newContext.Success)
{
newContext.Vars[Id] = idToken;
}
}
else
{
newContext.Vars[Id] = idToken;
newContext = newContext.AddMatch(idToken);
}
}
protected override MatchContext Match(Ust ust, MatchContext context)
{
return(ust is Expression expression
? context.AddMatch(expression)
: context.Fail());
}
public override MatchContext Match(ThisReferenceToken thisReferenceToken, MatchContext context)
{
return(context.AddMatch(thisReferenceToken));
}
public override MatchContext Match(Expression expression, MatchContext context)
{
return(context.AddMatch(expression));
}
protected override MatchContext Match(Ust ust, MatchContext context)
{
return(ust is NullLiteral nullLiteral
? context.AddMatch(nullLiteral)
: context.Fail());
}
public override MatchContext Match(BooleanLiteral booleanLiteral, MatchContext context)
{
return((Boolean == null || Boolean.Value.Equals(booleanLiteral.Value))
? context.AddMatch(booleanLiteral)
: context.Fail());
}
public override MatchContext Match(StringLiteral stringLiteral, MatchContext context)
{
return(String.Equals(stringLiteral.Text)
? context.AddMatch(stringLiteral)
: context.Fail());
}
public override MatchContext Match(Ust ust, MatchContext context)
{
var blockStatement = ust as BlockStatement;
if (blockStatement == null ||
(!(blockStatement.Parent is MethodDeclaration) &&
!(blockStatement.Parent is ConstructorDeclaration) &&
!(blockStatement.Parent is NamespaceDeclaration) &&
!(blockStatement.Parent is RootUst)))
{
return(context.Fail());
}
MatchContext newContext = MatchContext.CreateWithInputParamsAndVars(context);
if (Statements == null || Statements.Count == 0)
{
if (blockStatement.Statements == null || blockStatement.Statements.Count == 0)
{
newContext = newContext.AddMatch(blockStatement);
}
else
{
return(context.Fail());
}
}
else
{
IEnumerable <Statement> statements = blockStatement.Statements
.Where(statement =>
!(statement is TypeDeclarationStatement) &&
!(statement is WrapperStatement));
Expression[] expressions = statements.SelectMany(statement =>
statement
.WhereDescendants(descendant =>
descendant is Expression expressionDescendant &&
!(expressionDescendant is Token)))
.Cast <Expression>()
.ToArray();
var matchedTextSpans = new List <TextSpan>();
int patternStatementInd = 0;
bool success = false;
for (int i = 0; i < expressions.Length; i++)
{
newContext = MatchContext.CreateWithInputParamsAndVars(newContext);
newContext = Statements[patternStatementInd].MatchUst(expressions[i], newContext);
if (newContext.Success)
{
matchedTextSpans.AddRange(newContext.Locations);
patternStatementInd += 1;
if (patternStatementInd == Statements.Count)
{
success = true;
patternStatementInd = 0;
}
}
}
if (success)
{
context = context.AddMatches(matchedTextSpans);
}
else
{
context = context.Fail();
}
}
return(context);
}
public override MatchContext Match(BaseReferenceToken ust, MatchContext context)
{
return(context.AddMatch(ust));
}
public void AddMatch(Match match)
{
MatchContext.AddMatch(match);
}
public override MatchContext Match(IntLiteral intLiteral, MatchContext context)
{
return(intLiteral.Value == Value
? context.AddMatch(intLiteral)
: context.Fail());
}
public override MatchContext Match(NullLiteral nullLiteral, MatchContext context)
{
return(context.AddMatch(nullLiteral));
}
protected override MatchContext Match(Ust ust, MatchContext context)
{
return(ust is ThisReferenceToken thisReferenceToken
? context.AddMatch(thisReferenceToken)
: context.Fail());
}
public override MatchContext Match(BinaryOperatorLiteral binaryOperatorLiteral, MatchContext context)
{
return(BinaryOperator.Equals(binaryOperatorLiteral.BinaryOperator)
? context.AddMatch(binaryOperatorLiteral)
: context.Fail());
}