public JsonGrammar()
: base("json")
{
EnableMatchEvents = false;
CaseSensitive = true;
// terminals
var jstring = new StringParser { AllowEscapeCharacters = true, Name = "string" };
var jnumber = new NumberParser { AllowExponent = true, AllowSign = true, AllowDecimal = true, Name = "number" };
var jboolean = new BooleanTerminal { Name = "bool", TrueValues = new string[] { "true" }, FalseValues = new string[] { "false" }, CaseSensitive = false };
var jname = new StringParser { AllowEscapeCharacters = true, Name = "name" };
var jnull = new LiteralTerminal { Value = "null", Name = "null", CaseSensitive = false };
var ws = new RepeatCharTerminal(char.IsWhiteSpace);
var commaDelimiter = new RepeatCharTerminal(new RepeatCharItem(char.IsWhiteSpace), ',', new RepeatCharItem(char.IsWhiteSpace));
// nonterminals (things we're interested in getting back)
var jobject = new SequenceParser { Name = "object" };
var jarray = new SequenceParser { Name = "array" };
var jprop = new SequenceParser { Name = "property" };
// rules
var jvalue = jstring | jnumber | jobject | jarray | jboolean | jnull;
jobject.Add("{", (-jprop).SeparatedBy(commaDelimiter), "}");
jprop.Add(jname, ":", jvalue);
jarray.Add("[", (-jvalue).SeparatedBy(commaDelimiter), "]");
// separate sequence and repeating parsers by whitespace
jvalue.SeparateChildrenBy(ws, false);
// allow whitespace before and after the initial object or array
this.Inner = ws & (jobject | jarray) & ws;
}
void SetLine()
{
if (line != null)
{
lineSeq = line & new RepeatParser().Until(Terminals.Eol);
}
else
{
lineSeq = null;
}
}
void SetBlock()
{
if (start != null && end != null)
{
blockSeq = start & new RepeatParser().Until(end, true);
}
else
{
blockSeq = null;
}
}
protected SequenceParser(SequenceParser other, ParserCloneArgs chain)
: base(other, chain)
{
Separator = chain.Clone(other.Separator);
}
Parser SingleDefinition(Match match, bool isTerminal)
{
var terms = match.Find("term").ToArray();
if (terms.Length == 1)
return Term(terms[0], isTerminal);
else
{
var sequence = new SequenceParser(terms.Select(r => Term(r, isTerminal)));
if (!isTerminal)
sequence.Separator = separator;
return sequence;
}
}
public EbnfGrammar(EbnfStyle style)
: base("ebnf")
{
Style = style;
DefineCommonNonTerminals = true;
GenerateSpecialSequences();
// terminals
var comment = style.HasFlag(EbnfStyle.BracketComments) ? new GroupParser("(*", "*)") : new GroupParser("/*", "*/");
var ows = -(Terminals.WhiteSpace | comment);
var rws = +(Terminals.WhiteSpace | comment);
var hex_character = ("#x" & +Terminals.HexDigit);
var character = (("\\" & Terminals.AnyChar) | hex_character | Terminals.AnyChar.Except("]")).WithName("character");
var character_range = (character & "-" & character).WithName("character range");
var character_set = ("[" & ~(Parser)"^" & +(character_range | character) & "]").WithName("character set");
var terminal_string = new StringParser { QuoteCharacters = new [] { '\"', '\'', '’' }, Name = "terminal string" };
var special_sequence = ("?" & (+Terminals.AnyChar).Until("?").WithName("name") & "?").WithName("special sequence");
var meta_identifier_terminal = Terminals.Letter & -(Terminals.LetterOrDigit | '_');
var integer = new NumberParser().WithName("integer");
// nonterminals
var definition_list = new RepeatParser(0).WithName("definition list");
var single_definition = new RepeatParser(1).WithName("single definition");
var term = new SequenceParser().WithName("term");
var primary = new AlternativeParser().WithName("primary");
var exception = new UnaryParser("exception");
var factor = new SequenceParser().WithName("factor");
var meta_identifier = new RepeatParser(1).WithName("meta identifier");
var syntax_rule = new SequenceParser().WithName("syntax rule");
var rule_equals = new AlternativeParser().WithName("equals");
Parser meta_reference = meta_identifier;
Parser grouped_sequence = ("(" & ows & definition_list & ows & ")").WithName("grouped sequence");
if (style.HasFlag(EbnfStyle.SquareBracketAsOptional))
{
primary.Add(("[" & ows & definition_list & ows & "]").WithName("optional sequence"));
}
if (!style.HasFlag(EbnfStyle.CardinalityFlags))
{
var repeated_sequence = ("{" & ows & definition_list & ows & "}").WithName("repeated sequence");
primary.Add(repeated_sequence);
}
// rules
meta_identifier.Inner = meta_identifier_terminal;
meta_identifier.Separator = +(Terminals.SingleLineWhiteSpace);
if (!style.HasFlag(EbnfStyle.CommaSeparator))
{
// w3c identifiers must be a single word
meta_identifier.Maximum = 1;
meta_reference = meta_reference.NotFollowedBy(ows & rule_equals);
}
primary.Add(grouped_sequence, meta_reference, terminal_string, special_sequence);
if (style.HasFlag(EbnfStyle.CharacterSets) && !style.HasFlag(EbnfStyle.SquareBracketAsOptional))
{
// w3c supports character sets
primary.Add(hex_character.Named("hex character"));
primary.Add(character_set);
}
if (style.HasFlag(EbnfStyle.NumericCardinality))
factor.Add(~(integer & ows & "*" & ows));
factor.Add(primary);
if (style.HasFlag(EbnfStyle.CardinalityFlags))
{
// w3c defines cardinality at the end of a factor
var flags = style.HasFlag(EbnfStyle.SquareBracketAsOptional) ? "*+" : "?*+";
factor.Add(~(ows & Terminals.Set(flags).WithName("cardinality")));
}
term.Add(factor, ~(ows & "-" & ows & exception));
exception.Inner = term;
single_definition.Inner = term;
single_definition.Separator = style.HasFlag(EbnfStyle.CommaSeparator) ? (Parser)(ows & "," & ows) : ows;
definition_list.Inner = single_definition;
definition_list.Separator = ows & "|" & ows;
rule_equals.Add(style.HasFlag(EbnfStyle.DoubleColonEquals) ? "::=" : "=", ":=");
syntax_rule.Add(meta_identifier, ows, rule_equals, ows, definition_list);
if (style.HasFlag(EbnfStyle.SemicolonTerminator))
syntax_rule.Add(ows, ";"); // iso rules are terminated by a semicolon
var syntax_rules = +syntax_rule;
syntax_rules.Separator = style.HasFlag(EbnfStyle.SemicolonTerminator) ? ows : rws;
Inner = ows & syntax_rules & ows;
AttachEvents();
}
protected SequenceParser(SequenceParser other, ParserCloneArgs chain)
: base(other, chain)
{
Separator = chain.Clone(other.Separator);
}
void AttachEvents()
{
ruleName.Matched += m => {
Parser parser;
var name = m["name"].Text;
if (!parserLookup.TryGetValue(name, out parser) && !baseLookup.TryGetValue(name, out parser))
{
parser = Terminals.LetterOrDigit.Repeat();
parser.Name = name;
}
m.Tag = parser;
};
literal.Matched += m => m.Tag = new LiteralTerminal(m["value"].Text);
optionalRule.Matched += m => m.Tag = new OptionalParser((Parser)m["parser"].Tag);
repeatRule.Matched += m => m.Tag = new RepeatParser((Parser)m["parser"].Tag, 0) { Separator = sws };
list.Matched += m => {
if (m.Matches.Count > 1)
{
var parser = new SequenceParser();
foreach (var child in m.Matches)
{
if (child.Parser.Name == "ws")
parser.Items.Add(sws);
else if (child.Parser.Name == "term")
parser.Items.Add((Parser)child["parser"].Tag);
}
m.Tag = parser;
}
else
{
m.Tag = m["term"]["parser"].Tag;
}
};
listRepeat.Matched += m => {
// collapse alternatives to one alternative parser
var parser = (Parser)m["expression"]["parser"].Tag;
var alt = parser as AlternativeParser ?? new AlternativeParser(parser);
alt.Items.Insert(0, (Parser)m["list"]["parser"].Tag);
m.Tag = alt;
};
rule.Matched += m => {
var parser = (UnaryParser)m.Tag;
parser.Inner = (Parser)m["parser"].Tag;
m.Tag = parser;
};
rule.PreMatch += m => {
var name = m["ruleName"]["name"].Text;
Parser parser;
if (name == startParserName)
parser = new Grammar(name);
else
parser = new UnaryParser(name);
m.Tag = parser;
parserLookup[parser.Name] = parser;
};
}
public GoldGrammar()
: base("gold")
{
var oldSeparator = Parser.DefaultSeparator;
// Special Terminals
var parameterCh = Terminals.Printable - Terminals.Set("\"'");
var nonterminalCh = Terminals.LetterOrDigit | Terminals.Set("_-. ");
var terminalCh = Terminals.LetterOrDigit | Terminals.Set("_-.");
var literalCh = Terminals.Printable - Terminals.Set('\'');
var setLiteralCh = Terminals.Printable - Terminals.Set("[]'");
var setNameCh = Terminals.Printable - Terminals.Set("{}");
var parameterName = ('"' & (+parameterCh).WithName("value") & '"').Separate();
var nonterminal = ('<' & (+nonterminalCh).WithName("value") & '>').Separate();
var terminal = ((+terminalCh).WithName("terminal") | ('\'' & (-literalCh).WithName("literal") & '\'')).Separate();
var setLiteral = ('[' & +(setLiteralCh.WithName("ch") | '\'' & (-literalCh).WithName("ch") & '\'') & ']').WithName("setLiteral");
var setName = ('{' & (+setNameCh).WithName("value") & '}').WithName("setName");
// Line-Based Grammar Declarations
var comments = new GroupParser("!*", "*!", "!");
var newline = Terminals.Eol;
whitespace = -(Terminals.SingleLineWhiteSpace | comments);
Parser.DefaultSeparator = whitespace;
var nlOpt = -newline;
var nl = +newline | Terminals.End;
// Parameter Definition
var parameterItem = parameterName | terminal | setLiteral | setName | nonterminal;
var parameterItems = +parameterItem;
var parameterBody = parameterItems & -(nlOpt & '|' & parameterItems);
parameter = (parameterName.Named("name") & nlOpt & '=' & parameterBody.WithName("body") & nl).WithName("parameter");
// Set Definition
var 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();
var kleeneOpt = (~((Parser)'+' | '?' | '*')).WithName("kleene");
regExpItem = ((setLiteral & kleeneOpt)
| (setName & kleeneOpt)
| (terminal.Named("terminal") & kleeneOpt)
| ('(' & regExp2.Named("regExp2") & ')' & kleeneOpt)).WithName("regExpItem");
var regExpSeq = (+regExpItem).WithName("regExpSeq");
regExp2.Items.Add(regExpSeq);
regExp2.Items.Add(-('|' & regExpSeq));
regExp = (regExpSeq & -(nlOpt & '|' & regExpSeq)).WithName("regExp");
var 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");
var handles = handle & -(nlOpt & '|' & handle);
ruleDecl = (nonterminal.Named("name") & nlOpt & "::=" & handles & nl).WithName("ruleDecl");
// Rules
var definitionDecl = parameter | setDecl | terminalDecl | ruleDecl;
var content = -definitionDecl;
this.Inner = nlOpt & content & nlOpt;
Parser.DefaultSeparator = oldSeparator;
AttachEvents();
}
Parser Sequence(Match m, string innerName, Func<Match, Parser> inner, bool addWhitespace = false)
{
var parsers = m.Find(innerName).Select(inner).ToArray();
if (addWhitespace || parsers.Length > 1)
{
var sep = definition.Separator;
var seq = new SequenceParser(parsers) { Separator = sep };
if (addWhitespace && sep != null)
{
seq.Items.Insert(0, sep);
seq.Items.Add(sep);
}
return seq;
}
return parsers.FirstOrDefault();
}
void SetLine()
{
if (line != null)
lineSeq = line & new RepeatParser().Until(Terminals.Eol);
else
lineSeq = null;
}
void SetBlock()
{
if (start != null && end != null)
blockSeq = start & new RepeatParser().Until(end, true);
else
blockSeq = null;
}
