public BnfGrammar(bool enhanced = true)
: base("bnf")
{
if (enhanced)
{
#if CORECLR
foreach (var property in typeof(Terminals).GetTypeInfo().DeclaredProperties)
#else
foreach (var property in typeof(Terminals).GetProperties())
#endif
{
#if CORECLR
if (typeof(Parser).GetTypeInfo().IsAssignableFrom(property.PropertyType.GetTypeInfo()))
#else
if (typeof(Parser).IsAssignableFrom(property.PropertyType))
#endif
{
var parser = property.GetValue(null, null) as Parser;
baseLookup[property.Name] = parser.Named(property.Name);
}
}
}
var lineEnd = sws & +(sws & Terminals.Eol);
literal = (
(sq & (+!sq).WithName("value").Optional() & sq)
| (dq & (+!dq).WithName("value").Optional() & dq)
).WithName("parser");
RuleNameParser = "<" & Terminals.Set('>').Inverse().Repeat().WithName("name") & ">";
RuleParser = new AlternativeParser(); // defined later
TermParser = literal | (ruleName = RuleNameParser.Named("parser"));
TermParser.Name = "term";
if (enhanced)
{
TermParser.Items.Add('(' & sws & RuleParser & sws & ')');
TermParser.Items.Add(repeatRule = ('{' & sws & RuleParser & sws & '}').WithName("parser"));
TermParser.Items.Add(optionalRule = ('[' & sws & RuleParser & sws & ']').WithName("parser"));
}
list = (TermParser & -(~((+Terminals.SingleLineWhiteSpace).WithName("ws")) & TermParser)).WithName("parser");
listRepeat = (list.Named("list") & ws & '|' & sws & ~(RuleParser.Named("expression"))).WithName("parser");
RuleParser.Items.Add(listRepeat);
RuleParser.Items.Add(list);
rule = (~lineEnd & sws & RuleNameParser.Named("ruleName") & ws & ruleSeparator & sws & RuleParser & lineEnd).WithName("parser");
Expresssions = new AlternativeParser();
Expresssions.Items.Add(rule);
this.Inner = ws & +Expresssions & ws;
AttachEvents();
}
public EbnfGrammar()
: base("ebnf")
{
DefineCommonNonTerminals = true;
GenerateSpecialSequences();
// terminals
AlternativeParser terminal_string = ("'" & (+Terminals.AnyChar).Until("'").WithName("value") & "'")
| ("\"" & (+Terminals.AnyChar).Until("\"").WithName("value") & "\"")
| ("’" & (+Terminals.AnyChar).Until("’").WithName("value") & "’");
SequenceParser special_sequence =
("?" & (+Terminals.AnyChar).Until("?").WithName("name") & "?").WithName("special sequence");
SequenceParser meta_identifier_terminal = Terminals.Letter & -(Terminals.LetterOrDigit | '_');
var integer = new NumberParser();
Parser old = DefaultSeparator;
DefaultSeparator = cws;
// nonterminals
var definition_list = new UnaryParser("definition list");
var single_definition = new UnaryParser("single definition");
var term = new UnaryParser("term");
var primary = new UnaryParser("primary");
var exception = new UnaryParser("exception");
var factor = new UnaryParser("factor");
var meta_identifier = new UnaryParser("meta identifier");
var syntax_rule = new UnaryParser("syntax rule");
var rule_equals = new UnaryParser("equals");
SequenceParser optional_sequence = ("[" & definition_list & "]").WithName("optional sequence");
SequenceParser repeated_sequence = ("{" & definition_list & "}").WithName("repeated sequence");
SequenceParser grouped_sequence = ("(" & definition_list & ")").WithName("grouped sequence");
// rules
meta_identifier.Inner = (+meta_identifier_terminal).SeparatedBy(ws);
primary.Inner = optional_sequence | repeated_sequence
| special_sequence | grouped_sequence
| meta_identifier | terminal_string.Named("terminal string") | null;
factor.Inner = ~(integer.Named("integer") & "*") & primary;
term.Inner = factor & ~("-" & exception);
exception.Inner = term;
single_definition.Inner = term & -("," & term);
definition_list.Inner = single_definition & -("|" & single_definition);
rule_equals.Inner = (Parser)"=" | ":=";
syntax_rule.Inner = meta_identifier & rule_equals & definition_list & ";";
Inner = cws & +syntax_rule & cws;
DefaultSeparator = old;
AttachEvents();
}
public BnfGrammar(bool enhanced = true)
: base("bnf")
{
if (enhanced)
{
foreach (var terminal in Terminals.GetTerminals())
{
baseLookup[terminal.Item1] = terminal.Item2.Named(terminal.Item1);
}
}
literal = (
(sq & (+!sq).WithName("value").Optional() & sq)
| (dq & (+!dq).WithName("value").Optional() & dq)
| ((+(Terminals.WhiteSpace.Inverse().Except(Terminals.Set("<[{(|)}]>"))))).WithName("value")
).WithName("parser");
RuleNameParser = "<" & Terminals.Set("<>").Inverse().Repeat().WithName("name") & ">";
RuleParser = new AlternativeParser(); // defined later
TermParser = ((ruleName = RuleNameParser.Named("parser")).NotFollowedBy(ows & ruleSeparator)) | literal;
TermParser.Name = "term";
if (enhanced)
{
TermParser.Items.Add('(' & ows & RuleParser & ows & ')');
TermParser.Items.Add(repeatRule = ('{' & ows & RuleParser & ows & '}').WithName("parser"));
TermParser.Items.Add(optionalRule = ('[' & ows & RuleParser & ows & ']').WithName("parser"));
}
TermParser.Items.Add((ows & RuleNameParser & ows & ruleSeparator).Not() & Terminals.Set("<[{(}]>").WithName("value").Named("parser"));
list = (TermParser & -(~(rws.Named("ws")) & TermParser)).WithName("parser");
listRepeat = (list.Named("list") & ows & '|' & ~(ows & RuleParser.Named("expression"))).WithName("parser");
RuleParser.Items.Add(listRepeat);
RuleParser.Items.Add(list);
rule = (RuleNameParser.Named("ruleName") & ows & ruleSeparator & ows & RuleParser).WithName("parser");
Expresssions = new AlternativeParser();
Expresssions.Items.Add(rule);
this.Inner = ows & (+Expresssions).SeparatedBy(rws) & ows;
AttachEvents();
}
public BnfGrammar(BnfStyle style = BnfStyle.All)
: base("bnf")
{
Parser ows = Terminals.WhiteSpace.Repeat(0);
Parser rws = Terminals.WhiteSpace.Repeat(1);
if (style.HasFlag(BnfStyle.CommonTerminals))
{
foreach (var terminal in Terminals.GetTerminals())
{
baseLookup[terminal.Item1] = terminal.Item2;
}
}
if (style.HasFlag(BnfStyle.Comments))
{
// allow ebnf comments
var comment = new GroupParser("(*", "*)");
ows = (Terminals.WhiteSpace | comment).Repeat(0);
rws = (Terminals.WhiteSpace | comment).Repeat(1);
}
literal = (
(sq & (+!sq).WithName("value").Optional() & sq)
| (dq & (+!dq).WithName("value").Optional() & dq)
| (+Terminals.Set(" \n\r<[{(|)}]>").Inverse()).WithName("value")
).WithName("parser");
RuleNameParser = "<" & Terminals.Set("<>\n\r").Inverse().Repeat().WithName("name") & ">";
RuleParser = new AlternativeParser(); // defined later
TermParser = new AlternativeParser();
TermParser.Name = "term";
TermParser.Add((ruleName = RuleNameParser.Named("parser")).NotFollowedBy(ows & ruleSeparator));
if (style.HasFlag(BnfStyle.Cardinality))
{
TermParser.Items.Add('(' & ows & RuleParser & ows & ')');
TermParser.Items.Add(repeatRule = ('{' & ows & RuleParser & ows & '}').WithName("parser"));
TermParser.Items.Add(optionalRule = ('[' & ows & RuleParser & ows & ']').WithName("parser"));
}
TermParser.Items.Add(literal);
var rep = -(~((+Terminals.WhiteSpace).WithName("ws")) & TermParser);
rep.Name = "rep";
rep.AddMatch = false;
list = (TermParser & rep).WithName("parser");
listRepeat = (list.Named("list") & ows & '|' & ~(ows & RuleParser.Named("expression"))).WithName("parser");
RuleParser.Items.Add(listRepeat);
RuleParser.Items.Add(list);
RuleParser.Items.Add((ows & RuleNameParser & ows & ruleSeparator).Not() & Terminals.WhiteSpace.Inverse().Repeat().WithName("value").Named("parser"));
rule = (RuleNameParser.Named("ruleName") & ows & ruleSeparator & ows & RuleParser).WithName("parser");
Expresssions = new AlternativeParser();
Expresssions.Items.Add(rule);
this.Inner = ows & (+Expresssions).SeparatedBy(rws) & ows;
AttachEvents();
}
public GoldGrammar()
: base("gold")
{
Parser oldSeparator = DefaultSeparator;
// Special Terminals
ExceptParser parameterCh = Terminals.Printable - Terminals.Set("\"'");
AlternativeParser nonterminalCh = Terminals.LetterOrDigit | Terminals.Set("_-. ");
AlternativeParser terminalCh = Terminals.LetterOrDigit | Terminals.Set("_-.");
ExceptParser literalCh = Terminals.Printable - Terminals.Set('\'');
ExceptParser setLiteralCh = Terminals.Printable - Terminals.Set("[]'");
ExceptParser setNameCh = Terminals.Printable - Terminals.Set("{}");
SequenceParser parameterName = ('"' & (+parameterCh).WithName("value") & '"').Separate();
SequenceParser nonterminal = ('<' & (+nonterminalCh).WithName("value") & '>').Separate();
AlternativeParser terminal =
((+terminalCh).WithName("terminal") | ('\'' & (-literalCh).WithName("literal") & '\'')).Separate();
SequenceParser setLiteral =
('[' & +(setLiteralCh.WithName("ch") | '\'' & (-literalCh).WithName("ch") & '\'') & ']').WithName(
"setLiteral");
SequenceParser setName = ('{' & (+setNameCh).WithName("value") & '}').WithName("setName");
// Line-Based Grammar Declarations
var comments = new GroupParser("!*", "*!", "!");
Parser newline = Terminals.Eol;
whitespace = -(Terminals.SingleLineWhiteSpace | comments);
DefaultSeparator = whitespace;
RepeatParser nlOpt = -newline;
AlternativeParser nl = +newline | Terminals.End;
// Parameter Definition
AlternativeParser parameterItem = parameterName | terminal | setLiteral | setName | nonterminal;
RepeatParser parameterItems = +parameterItem;
SequenceParser parameterBody = parameterItems & -(nlOpt & '|' & parameterItems);
parameter =
(parameterName.Named("name") & nlOpt & '=' & parameterBody.WithName("body") & nl).WithName("parameter");
// Set Definition
AlternativeParser setItem = setLiteral | setName;
var setExp = new AlternativeParser {
Name = "setExp"
};
setExp.Add((setExp & nlOpt & '+' & setItem).WithName("add"),
(setExp & nlOpt & '-' & setItem).WithName("sub"),
setItem);
setDecl = (setName & nlOpt & '=' & setExp & nl).WithName("setDecl");
// Terminal Definition
var regExp2 = new SequenceParser();
OptionalParser kleeneOpt = (~((Parser)'+' | '?' | '*')).WithName("kleene");
regExpItem = ((setLiteral & kleeneOpt)
| (setName & kleeneOpt)
| (terminal.Named("terminal") & kleeneOpt)
| ('(' & regExp2.Named("regExp2") & ')' & kleeneOpt)).WithName("regExpItem");
RepeatParser regExpSeq = (+regExpItem).WithName("regExpSeq");
regExp2.Items.Add(regExpSeq);
regExp2.Items.Add(-('|' & regExpSeq));
regExp = (regExpSeq & -(nlOpt & '|' & regExpSeq)).WithName("regExp");
RepeatParser terminalName = +terminal;
terminalDecl = (terminalName.Named("name") & nlOpt & '=' & regExp & nl).WithName("terminalDecl");
// Rule Definition
symbol = (terminal.Named("terminal") | nonterminal.Named("nonterminal")).WithName("symbol");
handle = (-symbol).WithName("handle");
SequenceParser handles = handle & -(nlOpt & '|' & handle);
ruleDecl = (nonterminal.Named("name") & nlOpt & "::=" & handles & nl).WithName("ruleDecl");
// Rules
AlternativeParser definitionDecl = parameter | setDecl | terminalDecl | ruleDecl;
RepeatParser content = -definitionDecl;
Inner = nlOpt & content & nlOpt;
DefaultSeparator = oldSeparator;
AttachEvents();
}