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);