private bool TryRecognizeSimpleLiteralExpression(
QualifiedName fullyQualifiedName,
IEbnfLexerRuleExpression ebnfLexerRule,
out LexerRule lexerRule)
{
lexerRule = null;
if (ebnfLexerRule is EbnfLexerRuleExpressionSimple)
{
var term = ebnfLexerRule.Term;
if (term is EbnfLexerRuleTermConcatenation)
{
return(false);
}
var factor = term.Factor;
if (factor is EbnfLexerRuleFactorLiteral literal)
{
lexerRule = new StringLiteralLexerRule(literal.Value, new TokenName(fullyQualifiedName.FullName));
return(true);
}
}
return(false);
}
private void r_skip(ICollection <LexerRule> rules, string name, RExpr ex)
{
var rule = new LexerRule(name, new List <string> (), new List <string> (), new List <string> (),
"", true, ex);
rules.Add(rule);
TokenVocab [name] = _tokenVocabularyCounter++;
}
private void s(ICollection <LexerRule> rules, string name, string lexeme)
{
LexerRule rule = new LexerRule(name, new List <string> (), new List <string> (), new List <string> (),
"", false, new Str(lexeme));
rules.Add(rule);
TokenVocab [name] = _tokenVocabularyCounter++;
}
private void r_skip(List <LexerRule> rules, string name, RExpr ex)
{
LexerRule rule = new LexerRule(name, new List <string> (), new List <string> (), new List <string> (),
"", true, ex);
rules.Add(rule);
tokenVocab [name] = tokVocabCount++;
}
private void s(List <LexerRule> rules, string name, String lexeme)
{
LexerRule rule = new LexerRule(name, new List <string> (), new List <string> (), new List <string> (),
"", false, new Str(lexeme));
rules.Add(rule);
tokenVocab [name] = tokVocabCount++;
}
private void kw(ICollection <LexerRule> rules, string lexeme)
{
string name = lexeme.Replace("*", "_star_").Replace("#", "_hash_");
var rule = new LexerRule(name, new List <string> (), new List <string> (), new List <string> (),
"", false, new Str(lexeme));
rules.Add(rule);
TokenVocab [name] = _tokenVocabularyCounter++;
}
private void kw(List <LexerRule> rules, String lexeme)
{
string name = lexeme.Replace("*", "_star_").Replace("#", "_hash_");
LexerRule rule = new LexerRule(name, new List <string> (), new List <string> (), new List <string> (),
"", false, new Str(lexeme));
rules.Add(rule);
tokenVocab [name] = tokVocabCount++;
}
static EbnfGrammar()
{
LexerRule
settingIdentifier = CreateSettingIdentifierLexerRule(),
identifier = CreateIdentifierLexerRule(),
whitespace = CreateWhitespaceLexerRule(),
multiLineComment = CreateMultiLineCommentLexerRule();
ProductionExpression
definition = Definition,
block = Block,
rule = Rule,
setting = Setting,
lexerRule = LexerRule,
qualifiedIdentifier = QualifiedIdentifier,
expression = Expression,
term = Term,
factor = Factor,
literal = Literal,
grouping = Grouping,
repetition = Repetition,
optional = Optional,
lexerRuleExpression = LexerRuleExpression,
lexerRuleTerm = LexerRuleTerm,
lexerRuleFactor = LexerRuleFactor;
var regexProductionReference = new GrammarReferenceExpression(new RegexGrammar());
definition.Rule =
block
| (block + definition);
block.Rule =
rule
| setting
| lexerRule;
rule.Rule =
qualifiedIdentifier + '=' + expression + ';';
setting.Rule = (Expr)
settingIdentifier + '=' + qualifiedIdentifier + ';';
lexerRule.Rule =
qualifiedIdentifier + '~' + lexerRuleExpression + ';';
expression.Rule =
term
| (term + '|' + expression);
term.Rule =
factor
| (factor + term);
factor.Rule
= qualifiedIdentifier
| literal
| ('/' + regexProductionReference + '/')
| repetition
| optional
| grouping;
literal.Rule = (Expr)
new SimpleSingleQuoteStringLexerRule()
| new SimpleDoubleQuoteStringLexerRule();
repetition.Rule = (Expr)
'{' + expression + '}';
optional.Rule = (Expr)
'[' + expression + ']';
grouping.Rule = (Expr)
'(' + expression + ')';
qualifiedIdentifier.Rule =
identifier
| ((Expr)identifier + '.' + qualifiedIdentifier);
lexerRuleExpression.Rule =
lexerRuleTerm
| (lexerRuleTerm + '|' + lexerRuleExpression);
lexerRuleTerm.Rule =
lexerRuleFactor
| (lexerRuleFactor + lexerRuleTerm);
lexerRuleFactor.Rule =
literal
| ('/' + regexProductionReference + '/');
var grammarExpression = new GrammarExpression(
definition,
new[]
{
definition,
block,
rule,
setting,
lexerRule,
expression,
term,
factor,
literal,
repetition,
optional,
grouping,
qualifiedIdentifier,
lexerRuleExpression,
lexerRuleTerm,
lexerRuleFactor
},
new[] { whitespace, multiLineComment });
ebnfGrammar = grammarExpression.ToGrammar();
}
public LexerRuleModel(LexerRule lexerRule)
: base(lexerRule)
{
}
int ComputeHashCode()
{
return(HashCode.Compute(
LexerRule.GetHashCode(),
((int)NodeType).GetHashCode()));
}
static ParseRunnerTests()
{
whitespaceRule = CreateWhitespaceRule();
wordRule = CreateWordRule();
repeatingWordGrammar = CreateRepeatingWordGrammar();
}
protected Lexeme(LexerRule lexer, int position)
{
TokenName = lexer.TokenName;
Position = position;
}
