public static IRuleRef <TNode> DefineRule <TNode>(this IGrammarBuilder <TNode> grammar, string ruleDefinition) { var lexer = new Grammars.Peg.Lexer(new StringReader(ruleDefinition)); var protoRule = (ProtoRule)_pegParser.Value.Parse(new TokenStream(lexer).Start()); return(protoRule.Create(grammar)); }
public void Register(IGrammarBuilder <INode> grammar) { grammar.Choice("terminal", grammar.Ref("terminalType"), grammar.Ref("terminalLiteral"), grammar.Ref("terminalAny") ); }
public void Register(IGrammarBuilder <INode> grammar) { grammar.Sequence("definition", grammar.Terminal(TokenType.Identifier).As("name"), grammar.TerminalValue(":="), grammar.Ref("choice").As("rule") ).ReduceWith(Reduce); }
public void Register(IGrammarBuilder <INode> grammar) { grammar.Choice("atom", grammar.Ref("ruleRef"), grammar.Ref("terminal"), grammar.Sequence(null, grammar.TerminalValue("("), grammar.Ref("choice").Lift(), grammar.TerminalValue(")")) ); }
public void Register(IGrammarBuilder <INode> grammar) { grammar.Sequence("terminalType", grammar.TerminalValue("T"), grammar.TerminalValue("<"), grammar.Terminal(TokenType.Identifier).As("type"), grammar.TerminalValue(">") ).ReduceWith(Reduce); }
public void Register(IGrammarBuilder <INode> grammar) { grammar.Choice("range", grammar.TerminalValue("*"), grammar.TerminalValue("+"), grammar.TerminalValue("?"), grammar.Ref("minmax") ).ReduceWith(Reduce); }
public void Register(IGrammarBuilder <INode> grammar) { grammar.Sequence("choice", grammar.Ref("sequence"), grammar.ZeroOrMore(null, grammar.Sequence(null, grammar.TerminalValue("|"), grammar.Ref("sequence").Lift() )) ).ReduceWith(Reduce); }
public void Register(IGrammarBuilder <INode> grammar) { grammar.Sequence("minmax", grammar.TerminalValue("{"), grammar.Terminal(TokenType.Number).As("min"), grammar.Optional(null, grammar.TerminalValue(",")).As("sep"), grammar.Optional(null, grammar.Terminal(TokenType.Number)).As("max"), grammar.TerminalValue("}") ).ReduceWith(Reduce); }
private void DefineReferencedRulesAsDummies(IGrammarBuilder <INode> grammar, ProtoRule rule, HashSet <string> defined) { foreach (var child in rule.Children) { if (child.DisplayText == "Ref" && child.RuleName != null && !defined.Contains(child.RuleName)) { defined.Add(child.RuleName); grammar.DefineRule(child.RuleName, new MockRule(child.RuleName)); } DefineReferencedRulesAsDummies(grammar, child, defined); } }
public void Register(IGrammarBuilder <INode> grammar) { grammar.Choice("terminalLiteral", grammar.Terminal(TokenType.Literal), grammar.Sequence(null, grammar.TerminalValue("T"), grammar.TerminalValue("<"), grammar.Terminal(TokenType.Literal).Lift(), grammar.TerminalValue(">") ) ).ReduceWith(Reduce); }
public void Register(IGrammarBuilder <INode> grammar) { grammar.Sequence("atomExpression", grammar.Optional(null, grammar.Choice(null, grammar.TerminalValue("&"), grammar.TerminalValue("!") ) ).As("prefix"), grammar.Ref("atom"), grammar.Optional(null, grammar.Ref("range")).As("suffix") ).ReduceWith(Reduce); }
public void Register(IGrammarBuilder <INode> grammar) { grammar.Sequence("namedAtom", grammar.Ref("atomExpression").As("atom"), grammar.Optional(null, grammar.Choice(null, grammar.TerminalValue("#!"), grammar.Sequence(null, grammar.TerminalValue("#"), grammar.Terminal(TokenType.Identifier) )) ).As("name") ).ReduceWith(Reduce); }
public IRuleRef <TNode> Create <TNode>(IGrammarBuilder <TNode> grammar) { _grammarBuilderAdapter = new GrammarBuilderAdapter(rule => grammar.DefineRule(rule.Name, rule), name => grammar.Ref(name)); ArgAssert.NotNull(nameof(Factory), Factory); var rule = Factory(this); var ruleRef = grammar.DefineRule(rule.Name, rule); _grammarBuilderAdapter = null; if (RefName != null) { ruleRef.As(RefName); } return(ruleRef); }
public static void AddPolicy(IGrammarBuilder builder) { _builders.Insert(0, builder); }
public static IRuleRef <TNode> TerminalValue <TNode>(this IGrammarBuilder <TNode> grammar, string value, string?name = null) { return(grammar.DefineRule(name, new Terminal(name, new TokenValueMatcher(value)))); }
public void Register(IGrammarBuilder <INode> grammar) { grammar.Terminal(TokenType.Identifier, "ruleRef") .ReduceWith(Reduce); }
public static IRuleRef <TNode> Any <TNode>(this IGrammarBuilder <TNode> grammar, string?name) { return(grammar.DefineRule(name, new AnyTerminal(name))); }
public void Register(IGrammarBuilder <INode> grammar) { grammar.OneOrMore("sequence", grammar.Ref("namedAtom") ).ReduceWith(Reduce); }
public static IRuleRef <TNode> Repeat <TNode>(this IGrammarBuilder <TNode> grammar, string?name, IRuleRef rule, int min = 0, int max = -1) { return(grammar.DefineRule(name, new Repeat(name, rule, min, max))); }
public void Register(IGrammarBuilder <INode> grammar) { grammar.TerminalValue(".", "terminalAny") .ReduceWith(Reduce); }
public static IRuleRef <TNode> Terminal <TNode>(this IGrammarBuilder <TNode> grammar, ITokenMatcher matcher, string?name = null) { return(grammar.DefineRule(name, new Terminal(name, matcher))); }
public static IRuleRef <TNode> OneOrMore <TNode>(this IGrammarBuilder <TNode> grammar, string?name, IRuleRef rule) { return(grammar.DefineRule(name, new Repeat(name, rule, 1, -1))); }
public static IRuleRef <TNode> Not <TNode>(this IGrammarBuilder <TNode> grammar, string?name, IRuleRef target) { return(grammar.DefineRule(name, new Not(name, target))); }
public static IRuleRef <TNode> TerminalType <TNode>(this IGrammarBuilder <TNode> grammar, string tokenType, string?name = null) { return(grammar.DefineRule(name, new Terminal(name, tokenType))); }
public static IRuleRef <TNode> Terminal <TNode, TEnum>(this IGrammarBuilder <TNode> grammar, TEnum tokenType, string?name = null) where TEnum : System.Enum { return(grammar.DefineRule(name, new Terminal(name, tokenType.ToString()))); }
public static IRuleRef <TNode> Choice <TNode>(this IGrammarBuilder <TNode> grammar, string?name, IEnumerable <IRuleRef> rules) { return(grammar.DefineRule(name, new Choice(name, rules))); }
public static IRuleRef <TNode> Choice <TNode>(this IGrammarBuilder <TNode> grammar, string?name, params IRuleRef[] rules) { return(grammar.DefineRule(name, new Choice(name, rules))); }
public static IRuleRef <TNode> Optional <TNode>(this IGrammarBuilder <TNode> grammar, string?name, IRuleRef rule) { return(grammar.DefineRule(name, new Repeat(name, rule, 0, 1))); }