public Regex Parse(string regularExpression)
{
var grammar = new RegexGrammar();
var parseEngine = new ParseEngine(grammar, new ParseEngineOptions(optimizeRightRecursion: true));
var parseRunner = new ParseRunner(parseEngine, regularExpression);
while (!parseRunner.EndOfStream())
{
if (!parseRunner.Read())
{
throw new Exception(
$"Unable to parse regular expression. Error at position {parseRunner.Position}.");
}
}
if (!parseEngine.IsAccepted())
{
throw new Exception(
$"Error parsing regular expression. Error at position {parseRunner.Position}");
}
var parseForest = parseEngine.GetParseForestRootNode();
var parseTree = new InternalTreeNode(
parseForest as IInternalForestNode,
new SelectFirstChildDisambiguationAlgorithm());
var regexVisitor = new RegexVisitor();
parseTree.Accept(regexVisitor);
return(regexVisitor.Regex);
}
public Regex Parse(string regularExpression)
{
var grammar = new RegexGrammar();
var parseEngine = new ParseEngine(grammar, new ParseEngineOptions(optimizeRightRecursion: true));
var parseRunner = new ParseRunner(parseEngine, regularExpression);
while (!parseRunner.EndOfStream())
{
if (!parseRunner.Read())
throw new Exception(
$"Unable to parse regular expression. Error at position {parseRunner.Position}.");
}
if (!parseEngine.IsAccepted())
throw new Exception(
$"Error parsing regular expression. Error at position {parseRunner.Position}");
var parseForest = parseEngine.GetParseForestRootNode();
var parseTree = new InternalTreeNode(
parseForest as IInternalForestNode,
new SelectFirstChildDisambiguationAlgorithm());
var regexVisitor = new RegexVisitor();
parseTree.Accept(regexVisitor);
return regexVisitor.Regex;
}
public Regex Parse(string regularExpression)
{
var grammar = new RegexGrammar();
var parseEngine = new ParseEngine(grammar, new ParseEngineOptions());
var parseRunner = new ParseRunner(parseEngine, regularExpression);
while (!parseRunner.EndOfStream())
{
if (!parseRunner.Read())
{
throw new Exception(
$"Unable to parse regular expression. Error at position {parseRunner.Position}.");
}
}
if (!parseEngine.IsAccepted())
{
throw new Exception(
$"Error parsing regular expression. Error at position {parseRunner.Position}");
}
var parseTree = parseEngine.GetParseTree();
var regexVisitor = new RegexVisitor();
parseTree.Accept(regexVisitor);
return(regexVisitor.Regex);
}
static EbnfGrammar()
{
BaseLexerRule
settingIdentifier = CreateSettingIdentifierLexerRule(),
notDoubleQuote = CreateNotDoubleQuoteLexerRule(),
notSingleQuote = CreateNotSingleQuoteLexerRule(),
identifier = CreateIdentifierLexerRule(),
any = new TerminalLexerRule(new AnyTerminal(), "."),
notCloseBracket = new TerminalLexerRule(
new NegationTerminal(new CharacterTerminal(']')), "[^\\]]"),
notMeta = CreateNotMetaLexerRule(),
escapeCharacter = CreateEscapeCharacterLexerRule(),
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 regexGrammar = new RegexGrammar();
var regexProductionReference = new ProductionReferenceExpression(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)
'"' + notDoubleQuote + '"'
| (Expr)"'" + notSingleQuote + "'";
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[] { new LexerRuleModel(whitespace), new LexerRuleModel(multiLineComment) });
_ebnfGrammar = grammarExpression.ToGrammar();
}