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