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