public override bool Lex(GrammarDefinition grammar, string source, ref int offset)
{
for (int i = 0; i < Literal.Length; i++)
{
if ((offset + i) >= source.Length)
{
return(false);
}
if (grammar.IsCaseInsensitive)
{
if (char.ToLowerInvariant(source[offset + i]) != char.ToLowerInvariant(Literal[i]) &&
char.ToUpperInvariant(source[offset + i]) != char.ToUpperInvariant(Literal[i]))
{
return(false);
}
}
else
{
if (source[offset + i] != Literal[i])
{
return(false);
}
}
}
offset += Literal.Length;
return(true);
}
public override bool Lex(GrammarDefinition grammar, string source, ref int offset)
{
switch (Type)
{
case QuantificationType.ZeroOrMore:
while (Quantified.Lex(grammar, source, ref offset))
{
}
return(true);
case QuantificationType.OneOrMore:
if (!Quantified.Lex(grammar, source, ref offset))
{
return(false);
}
while (Quantified.Lex(grammar, source, ref offset))
{
}
return(true);
case QuantificationType.ZeroOrOne:
Quantified.Lex(grammar, source, ref offset);
return(true);
default:
throw new InvalidOperationException();
}
}
public bool Contains(GrammarDefinition grammar, char c)
{
if (grammar.IsCaseInsensitive)
{
return(ContainsSensitive(char.ToLowerInvariant(c)) || ContainsSensitive(char.ToUpperInvariant(c)));
}
else
{
return(ContainsSensitive(c));
}
}
public override bool Lex(GrammarDefinition grammar, string source, ref int offset)
{
foreach (var alt in Alternatives)
{
if (alt.Lex(grammar, source, ref offset))
{
return(true);
}
}
return(false);
}
public override bool Lex(GrammarDefinition grammar, string source, ref int offset)
{
var original = offset;
foreach (var item in Sequences)
{
if (!item.Lex(grammar, source, ref offset))
{
offset = original;
return(false);
}
}
return(true);
}
public override bool Lex(GrammarDefinition grammar, string source, ref int offset)
{
if (offset >= source.Length)
{
return(false);
}
if (CharsetContains(grammar, CharsetName, source[offset]))
{
offset++;
return(true);
}
else
{
return(false);
}
}
public override bool Contains(GrammarDefinition grammar, char c)
{
switch (Operator)
{
case CharsetBinaryOperator.Minus:
return(Left.Contains(grammar, c) && !Right.Contains(grammar, c));
case CharsetBinaryOperator.Plus:
return(Left.Contains(grammar, c) || Right.Contains(grammar, c));
case CharsetBinaryOperator.Div:
return(Left.Contains(grammar, c) && Right.Contains(grammar, c));
default:
throw new InvalidOperationException();
}
}
public override bool Contains(GrammarDefinition grammar, char c)
{
switch (Name)
{
case "Any":
return(true);
case "None":
return(false);
case "Digit":
return(char.IsDigit(c));
case "Letter":
return(char.IsLetter(c));
case "LetterOrDigit":
return(char.IsLetterOrDigit(c));
case "Number":
return(char.IsNumber(c));
case "Punctuation":
return(char.IsPunctuation(c));
case "Separator":
return(char.IsSeparator(c));
case "Symbol":
return(char.IsSymbol(c));
case "Upper":
return(grammar.IsCaseInsensitive || char.IsUpper(c));
case "Whitespace":
return(char.IsWhiteSpace(c));
case "Lower":
return(grammar.IsCaseInsensitive || char.IsLower(c));
default:
return(grammar.CharsetByName[Name].Expression.Contains(grammar, c));
}
}
public abstract bool Lex(GrammarDefinition grammar, string source, ref int offset);
public override bool Lex(GrammarDefinition grammar, string source, ref int offset)
{
return(grammar.RegexByName[Reference].Regex.Lex(grammar, source, ref offset));
}
public override bool Contains(GrammarDefinition grammar, char c)
{
return(ClassRegex.Contains(grammar, c));
}
public abstract bool Contains(GrammarDefinition grammar, char c);