public override int VisitOptional <TOutput>(OptionalParser <TInput, TOutput> parser, int start)
{
var oldPrevWasMissing = _prevWasMissing;
var len = Search(parser.Parser, start);
if (len < 0)
{
_prevWasMissing = oldPrevWasMissing;
return(0);
}
return(len);
}
public override Parser <TInput> VisitOptional <TOutput>(OptionalParser <TInput, TOutput> parser)
{
if (state.State == 0)
{
state.State = 1;
return(parser.Parser);
}
else if (state.LastResult < 0)
{
state.InputLength = 0;
return(null);
}
else
{
state.InputLength = state.LastResult;
return(null);
}
}
public override Parser <TInput> VisitOptional <TOutput>(OptionalParser <TInput, TOutput> parser)
{
if (state.State == 0)
{
state.State = 1;
return(parser.Parser);
}
else if (state.LastResult < 0)
{
state.InputLength = 0;
this.prevWasMissing = state.PrevWasMissing; // use initial missing state
return(null);
}
else
{
state.InputLength = state.LastResult;
return(null);
}
}
public override Parser <TInput> VisitOptional <TOutput>(OptionalParser <TInput, TOutput> parser)
{
if (state.State == 0)
{
state.State = 1;
state.NextOutputStart = output.Count;
return(parser.Parser);
}
else if (state.LastResult < 0)
{
output.SetCount(state.OriginalOutputCount);
output.Add(parser.Producer());
state.InputLength = 0;
return(null);
}
else
{
state.InputLength = state.LastResult;
return(null);
}
}
Parser Factor(Match match, bool isTerminal)
{
var primary = Primary(match["primary"], isTerminal);
var cardinality = match["cardinality"];
if (cardinality)
{
switch (cardinality.Text)
{
case "?":
primary = new OptionalParser(primary);
break;
case "*":
primary = new RepeatParser(primary, 0);
break;
case "+":
primary = new RepeatParser(primary, 1);
break;
default:
throw new FormatException(string.Format("Cardinality '{0}' is unknown", cardinality.Text));
break;
}
}
var integer = match["integer"];
if (integer)
{
return(new RepeatParser(primary, Int32.Parse(integer.Text)));
}
else
{
return(primary);
}
}
public XmlGrammar()
: base("xml")
{
EnableMatchEvents = false;
var comment = new GroupParser("<!--", "-->");
RepeatCharTerminal ws = Terminals.Repeat(Char.IsWhiteSpace, 1);
RepeatCharTerminal ows = Terminals.Repeat(Char.IsWhiteSpace, 0);
RepeatParser wsc = -(ws | comment);
RepeatCharTerminal name = Terminals.Repeat(new RepeatCharItem(Char.IsLetter, 1, 1),
new RepeatCharItem(Char.IsLetterOrDigit, 0));
RepeatCharTerminal namedName =
Terminals.Repeat(new RepeatCharItem(Char.IsLetter, 1, 1), new RepeatCharItem(Char.IsLetterOrDigit, 0)).
WithName("name");
UntilParser text = new UntilParser("<", 1).WithName("text");
var attributeValue = new StringParser {
QuoteCharacters = new[] { '"' }, Name = "value"
};
SequenceParser attribute = (namedName & ows & "=" & ows & attributeValue);
OptionalParser attributes = (ws & (+attribute).SeparatedBy(ws).WithName("attributes")).Optional();
var content = new RepeatParser {
Separator = wsc
};
SequenceParser startTag = "<" & namedName & attributes & ows;
SequenceParser endTag = "</" & name & ">";
SequenceParser obj = (startTag & ("/>" | (">" & wsc & content & wsc & endTag))).WithName("object");
SequenceParser cdata = ("<![CDATA[" & new UntilParser("]]>", 0, skip: true)).WithName("cdata");
content.Inner = obj | text | cdata;
SequenceParser declaration = "<?" & name & attributes & ows & "?>";
Inner = declaration & wsc & obj & wsc;
}
public override IParser Create(MemberInfo member, ChildParser child, IConfig config)
{
var s = new OptionalParser(new WhitespaceParser(config, ParserFlags), config, ParserFlags);
return(new SurroundParser(s, child(null), s, config, ParserFlags));
}
public override void VisitOptional <TOutput>(OptionalParser <TInput, TOutput> parser)
{
WriteOptional(parser.Parser);
}
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();
}
protected OptionalParser(OptionalParser other, ParserCloneArgs chain)
: base(other, chain)
{
}
