public CompletionGrammar() : base(new ParserSettings())
{
IncompleteCode = TkCode(Ch("${").Or(Ch("!{"))).And(Text)
.Build(hit => new ExpressionNode(hit.Down.Text));
var LessThanTextNode = Ch('<').Build(hit => (Node) new TextNode("<"));
var EntityRefOrAmpersand = AsNode(EntityRef).Or(Ch('&').Build(hit => (Node) new TextNode("&")));
AnyNode =
AsNode(Element).Paint()
.Or(AsNode(EndElement).Paint())
.Or(EntityRefOrAmpersand.Paint())
.Or(AsNode(Statement))
.Or(AsNode(Code).Paint())
.Or(AsNode(IncompleteCode).Paint())
.Or(AsNode(Text).Paint())
.Or(AsNode(DoctypeDecl).Paint())
.Or(AsNode(Comment).Paint())
.Or(AsNode(XMLDecl).Paint())
.Or(AsNode(ProcessingInstruction).Paint())
.Or(AsNode(LessThanTextNode).Paint());
Nodes = Rep(AnyNode);
}
public BindingGrammar()
{
ParseAction <char> parse = CharGrammar.Ch(new Func <char, bool>(char.IsLetterOrDigit)).Or <char>(CharGrammar.Ch(new char[] { '.', '-', '_', ':' }));
ParseAction <string> action2 = CharGrammar.Ch(new Func <char, bool>(char.IsLetter)).Or <char>(CharGrammar.Ch(new char[] { '_', ':' })).And <char, IList <char> >(Grammar.Rep <char>(parse)).Build <Chain <char, IList <char> >, string>(hit => hit.Left + new string(hit.Down.ToArray <char>()));
ParseAction <BindingPrefixReference> action3 = CharGrammar.Ch("\"@").And <string, string>(Grammar.Opt <string>(action2)).And <Chain <string, string>, string>(CharGrammar.Ch("*\"")).Or <Chain <Chain <string, string>, string> >(CharGrammar.Ch("'@").And <string, string>(Grammar.Opt <string>(action2)).And <Chain <string, string>, string>(CharGrammar.Ch("*'"))).Build <Chain <Chain <string, string>, string>, BindingPrefixReference>(hit => new BindingPrefixReference(hit.Left.Down)
{
AssumeStringValue = true
});
ParseAction <BindingPrefixReference> action4 = CharGrammar.Ch('@').And <char, string>(Grammar.Opt <string>(action2)).And <Chain <char, string>, char>(CharGrammar.Ch('*')).Build <Chain <Chain <char, string>, char>, BindingPrefixReference>(hit => new BindingPrefixReference(hit.Left.Down));
ParseAction <BindingPrefixReference> action5 = CharGrammar.Ch("{{").And <string, BindingPrefixReference>(action3.Or <BindingPrefixReference>(action4)).And <Chain <string, BindingPrefixReference>, string>(CharGrammar.Ch("}}")).Build <Chain <Chain <string, BindingPrefixReference>, string>, BindingPrefixReference>(delegate(Chain <Chain <string, BindingPrefixReference>, string> hit) {
hit.Left.Down.AssumeDictionarySyntax = true;
return(hit.Left.Down);
});
this.PrefixReference = action3.Or <BindingPrefixReference>(action4).Or <BindingPrefixReference>(action5).Build <BindingPrefixReference, BindingNode>(hit => hit);
ParseAction <BindingNode> action6 = CharGrammar.Ch("\"@").And <string, string>(action2).And <Chain <string, string>, char>(CharGrammar.Ch('"')).Or <Chain <Chain <string, string>, char> >(CharGrammar.Ch("'@").And <string, string>(action2).And <Chain <string, string>, char>(CharGrammar.Ch('\''))).Build <Chain <Chain <string, string>, char>, BindingNode>(hit => new BindingNameReference(hit.Left.Down)
{
AssumeStringValue = true
});
ParseAction <BindingNode> action7 = CharGrammar.Ch('@').And <char, string>(action2).Build <Chain <char, string>, BindingNode>(hit => new BindingNameReference(hit.Down));
ParseAction <BindingNode> action8 = CharGrammar.Ch("child::*").Or <string>(CharGrammar.Ch("'child::*'")).Or <string>(CharGrammar.Ch("\"child::*\"")).Build <string, BindingNode>(hit => new BindingChildReference());
this.NameReference = action6.Or <BindingNode>(action7);
ParseAction <BindingNode> action9 = this.PrefixReference.Or <BindingNode>(this.NameReference).Or <BindingNode>(action8);
ParseAction <char> action10 = CharGrammar.Ch("[[").Build <string, char>(hit => '<').Or <char>(CharGrammar.Ch("]]").Build <string, char>(hit => '>'));
ParseAction <char> action11 = CharGrammar.Ch((Func <char, bool>)(ch => true)).Unless <char, BindingNode>(action9).Unless <char, char>(action10);
this.Literal = Grammar.Rep1 <char>(action10.Or <char>(action11)).Build <IList <char>, BindingNode>(hit => new BindingLiteral(hit));
this.Nodes = Grammar.Rep <BindingNode>(action9.Or <BindingNode>(this.Literal));
this.Phrase = CharGrammar.Ch("#").And <string, IList <BindingNode> >(this.Nodes).Build <Chain <string, IList <BindingNode> >, BindingPhrase>(hit => new BindingPhrase {
Type = BindingPhrase.PhraseType.Statement, Nodes = hit.Down
}).Or <BindingPhrase>(this.Nodes.Build <IList <BindingNode>, BindingPhrase>(hit => new BindingPhrase {
Type = BindingPhrase.PhraseType.Expression, Nodes = hit
}));
}
/// <summary>
/// Indicates a conjunction (logical and) between two matches.
/// </summary>
/// <typeparam name="TValue1">The type of the first match.</typeparam>
/// <typeparam name="TValue2">The type of the second match.</typeparam>
/// <param name="p1">The first requirement in the conjunction.</param>
/// <param name="p2">The second requirement in the conjunction.</param>
/// <returns>The corresponding ParseAction for this match.</returns>
/// <remarks>
/// When a match is found, the two results are chained together.
/// The first match corresponds to Chain.Left, and the second to Chain.Down.
/// </remarks>
public static ParseAction <Chain <TValue1, TValue2> > And <TValue1, TValue2>(
ParseAction <TValue1> p1,
ParseAction <TValue2> p2)
{
return(delegate(Position input)
{
var r1 = p1(input);
if (r1 == null)
{
return null;
}
var r2 = p2(r1.Rest);
if (r2 == null)
{
return null;
}
var chain = new Chain <TValue1, TValue2>(
r1.Value,
r2.Value);
return new ParseResult <Chain <TValue1, TValue2> >(
r2.Rest,
chain);
});
}
public CompletionGrammar()
: base(new ParserSettings())
{
IncompleteCode = TkCode(Ch("${").Or(Ch("!{"))).And(Text)
.Build(hit => new ExpressionNode(hit.Down.Text));
var LessThanTextNode = Ch('<').Build(hit => (Node) new TextNode("<"));
var EntityRefOrAmpersand = AsNode(EntityRef).Or(Ch('&').Build(hit => (Node)new TextNode("&")));
AnyNode =
AsNode(Element).Paint()
.Or(AsNode(EndElement).Paint())
.Or(EntityRefOrAmpersand.Paint())
.Or(AsNode(Statement))
.Or(AsNode(Code).Paint())
.Or(AsNode(IncompleteCode).Paint())
.Or(AsNode(Text).Paint())
.Or(AsNode(DoctypeDecl).Paint())
.Or(AsNode(Comment).Paint())
.Or(AsNode(XMLDecl).Paint())
.Or(AsNode(ProcessingInstruction).Paint())
.Or(AsNode(LessThanTextNode).Paint());
Nodes = Rep(AnyNode);
}
public string ActionsToString()
{
const string separator = "\t";
// actually pivoted table printout, becase symbol names take more space
// so columns are rows, and rows are columns
string header = separator + String.Join(separator, Enumerable.Range(0, actionsTable.GetLength(0)).Select(col => col.ToString()));
Tuple <string, string>[] rows =
enumerate(LookaheadWidth).Select(chunk => Tuple.Create(chunk.ToString(symbolsRep),
String.Join(separator, Enumerable.Range(0, actionsTable.GetLength(0)).Select(col =>
{
string str = "";
ParseAction <SYMBOL_ENUM, TREE_NODE> action = GetSingle(col, chunk.Symbols);
if (action != null && action.Shift)
{
str += "S";
}
if (action != null && action.HasAnyReduction)
{
str += (action.Reductions.Length > 1 ? "RR" : "R");
}
return(str);
})))).ToArray();
return(String.Join(Environment.NewLine, LinqExtensions.Concat(header, rows.OrderBy(it => it.Item1).Select(it => it.Item1 + separator + it.Item2))));
}
private string dumpParseAction(ParseAction <int, object> parseAction, string symbolTypeName, Func <int, string> symbolNameConvert, string treeNodeName)
{
return(CodeWords.New + " ParseAction<" + symbolTypeName + "," + treeNodeName + ">(" + (parseAction.Shift ? "true" : "false")
+ (!parseAction.HasAnyReduction ? "" : ","
+ String.Join(",", parseAction.Reductions.Select(it => dumpReductionAction(it, symbolTypeName, symbolNameConvert, treeNodeName))))
+ ")");
}
public UseMasterGrammar()
{
ParseAction <IList <char> > whiteSpace0 = Rep(Ch(char.IsWhiteSpace));
ParseAction <IList <char> > whiteSpace1 = Rep1(Ch(char.IsWhiteSpace));
ParseAction <string> startOfElement = Ch("<use");
ParseAction <Chain <Chain <Chain <string, IList <char> >, char>, IList <char> > > startOfAttribute = Ch("master").And(whiteSpace0).And(Ch('=')).And(whiteSpace0);
ParseAction <Chain <Chain <char, IList <char> >, char> > attrValue = Ch('\'').And(Rep(ChNot('\''))).And(Ch('\''))
.Or(Ch('\"').And(Rep(ChNot('\"'))).And(Ch('\"')));
ParseAction <string> endOfElement = Ch("/>");
ParseAction <string> useMaster = startOfElement
.And(whiteSpace1)
.And(startOfAttribute)
.And(attrValue)
.And(whiteSpace0)
.And(endOfElement)
.Build(hit => new string(hit.Left.Left.Down.Left.Down.ToArray()));
ParseUseMaster =
pos =>
{
for (Position scan = pos; scan.PotentialLength() != 0; scan = scan.Advance(1))
{
ParseResult <string> result = useMaster(scan);
if (result != null)
{
return(result);
}
}
return(null);
};
}
public override IList <Chunk> GetChunks(VisitorContext context, string path)
{
context.SyntaxProvider = this;
context.ViewPath = path;
Position position = new Position(AbstractSyntaxProvider.CreateSourceContext(context.ViewPath, context.ViewFolder));
ParseAction <IList <Node> > action = string.Equals(Path.GetExtension(path), Constants.DotShade, StringComparison.OrdinalIgnoreCase) ? this._grammar.OffsetNodes : this._grammar.Nodes;
ParseResult <IList <Node> > result = action(position);
if (result.Rest.PotentialLength() != 0)
{
base.ThrowParseException(context.ViewPath, position, result.Rest);
}
context.Paint = result.Rest.GetPaint();
IList <Node> nodes = result.Value;
foreach (INodeVisitor visitor in this.BuildNodeVisitors(context))
{
visitor.Accept(nodes);
nodes = visitor.Nodes;
}
ChunkBuilderVisitor visitor2 = new ChunkBuilderVisitor(context);
visitor2.Accept(nodes);
return(visitor2.Chunks);
}
public JavascriptAnonymousTypeGrammar()
{
ParseAction <IList <char> > action = Grammar.Rep <char>(CharGrammar.Ch(new char[] { ' ', '\t', '\r', '\n' }));
ParseAction <Chain <char, IList <char> > > parser = CharGrammar.Ch(new Func <char, bool>(char.IsLetter)).Or <char>(CharGrammar.Ch('_')).And <char, IList <char> >(Grammar.Rep <char>(CharGrammar.Ch(new Func <char, bool>(char.IsLetterOrDigit)).Or <char>(CharGrammar.Ch('_'))));
ParseAction <Chain <Chain <char, IList <char> >, char> > action3 = CharGrammar.Ch('"').And <char, IList <char> >(Grammar.Rep <char>(CharGrammar.ChNot('"'))).And <Chain <char, IList <char> >, char>(CharGrammar.Ch('"'));
ParseAction <Chain <Chain <char, IList <char> >, char> > action4 = CharGrammar.Ch('\'').And <char, IList <char> >(Grammar.Rep <char>(CharGrammar.ChNot('\''))).And <Chain <char, IList <char> >, char>(CharGrammar.Ch('\''));
ParseAction <string> action5 = new ParseAction <string>(this.ValuePart);
ParseAction <IList <string> > action7 = Grammar.Rep <string>(Str <IList <char> >(Grammar.Rep1 <char>(CharGrammar.ChNot(new char[] { '}', ',' }).Unless <char, string>(action5))).Or <string>(action5));
ParseAction <string> action8 = action.And <IList <char>, string>(Str <Chain <char, IList <char> > >(parser)).And <Chain <IList <char>, string>, IList <char> >(action).And <Chain <Chain <IList <char>, string>, IList <char> >, char>(CharGrammar.Ch('=')).And <Chain <Chain <Chain <IList <char>, string>, IList <char> >, char>, IList <char> >(action).And <Chain <Chain <Chain <Chain <IList <char>, string>, IList <char> >, char>, IList <char> >, IList <string> >(action7).Build <Chain <Chain <Chain <Chain <Chain <IList <char>, string>, IList <char> >, char>, IList <char> >, IList <string> >, string>(hit => hit.Left.Left.Left.Left.Down + ":" + string.Concat(hit.Down.ToArray <string>()));
ParseAction <Chain <Chain <IList <char>, char>, IList <char> > > action9 = action.And <IList <char>, char>(CharGrammar.Ch(',')).And <Chain <IList <char>, char>, IList <char> >(action);
ParseAction <IEnumerable <string> > action10 = action8.And <string, IList <Chain <Chain <Chain <IList <char>, char>, IList <char> >, string> > >(Grammar.Rep <Chain <Chain <Chain <IList <char>, char>, IList <char> >, string> >(action9.And <Chain <Chain <IList <char>, char>, IList <char> >, string>(action8))).Build <Chain <string, IList <Chain <Chain <Chain <IList <char>, char>, IList <char> >, string> > >, IEnumerable <string> >(hit => new string[] { hit.Left }.Concat <string>(from x in hit.Down select x.Down));
ParseAction <string> action11 = CharGrammar.Ch("new").And <string, IList <char> >(action).And <Chain <string, IList <char> >, char>(CharGrammar.Ch('{')).And <Chain <Chain <string, IList <char> >, char>, IEnumerable <string> >(action10).And <Chain <Chain <Chain <string, IList <char> >, char>, IEnumerable <string> >, char>(CharGrammar.Ch('}')).Build <Chain <Chain <Chain <Chain <string, IList <char> >, char>, IEnumerable <string> >, char>, string>(hit => "{" + string.Join(",", hit.Left.Down.ToArray <string>()) + "}");
this._valuePart = Str <Chain <Chain <char, IList <char> >, char> >(action3.Or <Chain <Chain <char, IList <char> >, char> >(action4)).Or <string>(action11);
ParseAction <IList <char> > action12 = Grammar.Rep1 <char>(CharGrammar.Ch((Func <char, bool>)(ch => true)).Unless <char, string>(action11));
this.ReformatCode = Grammar.Rep <string>(Str <IList <char> >(action12).Or <string>(action11)).Build <IList <string>, string>(hit => string.Concat(hit.ToArray <string>()));
this.test_ws = Test <IList <char> >(action);
this.test_doubleString = Test <Chain <Chain <char, IList <char> >, char> >(action3);
this.test_singleString = Test <Chain <Chain <char, IList <char> >, char> >(action4);
this.test_propName = Test <Chain <char, IList <char> > >(parser);
this.test_propValue = Test <IList <string> >(action7);
this.test_term = Test <string>(action8);
this.test_terms = Test <IEnumerable <string> >(action10);
this.test_anonymousType = action11;
}
public CSharpGrammar()
{
ParseAction <Node> action = CharGrammar.Ch("${").And <string, IList <char> >(Grammar.Rep1 <char>(CharGrammar.ChNot('}'))).And <Chain <string, IList <char> >, char>(CharGrammar.Ch('}')).Build <Chain <Chain <string, IList <char> >, char>, Node>(hit => new ExpressionNode(new string(hit.Left.Down.ToArray <char>())));
ParseAction <Node> action2 = Grammar.Opt <char>(CharGrammar.Ch('\r')).And <char, char>(CharGrammar.Ch('\n')).And <Chain <char, char>, IList <char> >(Grammar.Rep <char>(CharGrammar.Ch(new Func <char, bool>(char.IsWhiteSpace)))).And <Chain <Chain <char, char>, IList <char> >, string>(CharGrammar.Ch("//:")).And <Chain <Chain <Chain <char, char>, IList <char> >, string>, IList <char> >(Grammar.Rep <char>(CharGrammar.ChNot(new char[] { '\r', '\n' }))).Build <Chain <Chain <Chain <Chain <char, char>, IList <char> >, string>, IList <char> >, Node>(hit => new StatementNode(new string(hit.Down.ToArray <char>())));
ParseAction <Node> action3 = Grammar.Rep1 <char>(CharGrammar.Ch((Func <char, bool>)(c => true)).Unless <char, Node>(action2).Unless <char, Node>(action)).Build <IList <char>, Node>(hit => new TextNode(hit));
this.Nodes = Grammar.Rep <Node>(action2.Or <Node>(action).Or <Node>(action3));
}
private string GenerateConsumeString(ParseAction action)
{
ConsumeString consume = (ConsumeString)action;
return(this.WrapAssignment(action,
(consume.IsOptional ? "Maybe" : "") + "Consume(\"" + consume.String + "\")"
) + ";");
}
public CodeGrammar()
{
Func <ParseAction <string>, ParseAction <Snippets> > func = null;
Func <IList <char>, string> bs = hit => new string(hit.ToArray <char>());
Func <IList <string>, string> js = hit => string.Concat(hit.ToArray <string>());
ParseAction <string> action = CharGrammar.Ch('\\').And <char, char>(CharGrammar.Ch((Func <char, bool>)(c => true))).Build <Chain <char, char>, string>(hit => @"\" + hit.Down);
ParseAction <string> parse = Grammar.Rep1 <char>(CharGrammar.ChNot(new char[] { '"', '\\' })).Build <IList <char>, string>(bs).Or <string>(action);
ParseAction <IList <Snippet> > action3 = Snip <Chain <Chain <char, IList <string> >, char> >(CharGrammar.Ch('"').And <char, IList <string> >(Grammar.Rep <string>(parse)).And <Chain <char, IList <string> >, char>(CharGrammar.Ch('"')), (Func <Chain <Chain <char, IList <string> >, char>, string>)(hit => ("\"" + js(hit.Left.Down) + "\"")));
ParseAction <string> action4 = CharGrammar.Ch("\"\"").Or <string>(CharGrammar.ChNot('"').Build <char, string>(ch => new string(ch, 1)));
ParseAction <IList <Snippet> > action5 = Snip <Chain <Chain <string, IList <string> >, char> >(CharGrammar.Ch("@\"").And <string, IList <string> >(Grammar.Rep <string>(action4)).And <Chain <string, IList <string> >, char>(CharGrammar.Ch('"')), (Func <Chain <Chain <string, IList <string> >, char>, string>)(hit => ("@\"" + js(hit.Left.Down) + "\"")));
ParseAction <IList <Snippet> > action6 = Snip(Grammar.Rep1 <char>(CharGrammar.ChNot(new char[] { '\'', '\\', '"' }))).Or <IList <Snippet> >(Snip(action)).Or <IList <Snippet> >(Swap <char>(CharGrammar.Ch('"'), "\\\""));
ParseAction <IList <Snippet> > action7 = Snip(Swap <char>(CharGrammar.Ch('\''), "\"").And <IList <Snippet>, IList <Snippet> >(Snip(Grammar.Rep <IList <Snippet> >(action6))).And <Chain <IList <Snippet>, IList <Snippet> >, IList <Snippet> >(Swap <char>(CharGrammar.Ch('\''), "\"")));
ParseAction <IList <Snippet> > action8 = Swap <string>(CharGrammar.Ch("''"), "'").Or <IList <Snippet> >(Swap <char>(CharGrammar.Ch('"'), "\"\"")).Or <IList <Snippet> >(Snip(CharGrammar.ChNot('\'')));
ParseAction <IList <Snippet> > action9 = Snip(Swap <string>(CharGrammar.Ch("@'"), "@\"").And <IList <Snippet>, IList <Snippet> >(Snip(Grammar.Rep <IList <Snippet> >(action8))).And <Chain <IList <Snippet>, IList <Snippet> >, IList <Snippet> >(Swap <char>(CharGrammar.Ch('\''), "\"")));
ParseAction <IList <Snippet> > stringLiteral = TkStr <IList <Snippet> >(action3.Or <IList <Snippet> >(action5).Or <IList <Snippet> >(action7).Or <IList <Snippet> >(action9));
this._stringLiteral = stringLiteral;
ParseAction <IList <Snippet> > SpecialCharCast = Snip <Chain <Chain <string, string>, char> >(CharGrammar.Ch("(char)'").And <string, string>(CharGrammar.ChNot(new char[] { '\'', '\\' }).Build <char, string>(ch => ch.ToString()).Or <string>(action)).And <Chain <string, string>, char>(CharGrammar.Ch('\'')), (Func <Chain <Chain <string, string>, char>, string>)(hit => ("(char)'" + hit.Left.Down + "'")));
ParseAction <IList <Snippet> > oneLineComment = Snip <Chain <string, IList <char> > >(CharGrammar.Ch("//").And <string, IList <char> >(Grammar.Rep <char>(CharGrammar.ChNot(new char[] { '\r', '\n' }))), (Func <Chain <string, IList <char> >, string>)(hit => ("//" + bs(hit.Down))));
ParseAction <IList <Snippet> > multiLineComment = Snip <Chain <Chain <string, IList <char> >, string> >(CharGrammar.Ch("/*").And <string, IList <char> >(Grammar.Rep <char>(CharGrammar.Ch((Func <char, bool>)(c => true)).Unless <char, string>(CharGrammar.Ch("*/")))).And <Chain <string, IList <char> >, string>(CharGrammar.Ch("*/")), (Func <Chain <Chain <string, IList <char> >, string>, string>)(hit => ("/*" + bs(hit.Left.Down) + "*/")));
ParseAction <char> action10 = CharGrammar.Ch((Func <char, bool>)(c => (char.GetUnicodeCategory(c) == UnicodeCategory.ConnectorPunctuation)));
ParseAction <char> action11 = CharGrammar.Ch(delegate(char c) {
if (char.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark)
{
return(char.GetUnicodeCategory(c) == UnicodeCategory.SpacingCombiningMark);
}
return(true);
});
ParseAction <char> action12 = CharGrammar.Ch((Func <char, bool>)(c => (char.GetUnicodeCategory(c) == UnicodeCategory.Format)));
ParseAction <char> action13 = CharGrammar.Ch(new Func <char, bool>(char.IsLetter)).Or <char>(CharGrammar.Ch('_'));
ParseAction <char> action14 = CharGrammar.Ch(new Func <char, bool>(char.IsLetterOrDigit)).Or <char>(action10).Or <char>(action11).Or <char>(action12);
ParseAction <string> action15 = action13.And <char, IList <char> >(Grammar.Rep <char>(action14)).Build <Chain <char, IList <char> >, string>(hit => hit.Left + new string(hit.Down.ToArray <char>()));
ParseAction <IList <Snippet> > keyword = Snip(CharGrammar.Ch("abstract").Or <string>(CharGrammar.Ch("as")).Or <string>(CharGrammar.Ch("base")).Or <string>(CharGrammar.Ch("bool")).Or <string>(CharGrammar.Ch("break")).Or <string>(CharGrammar.Ch("byte")).Or <string>(CharGrammar.Ch("case")).Or <string>(CharGrammar.Ch("catch")).Or <string>(CharGrammar.Ch("char")).Or <string>(CharGrammar.Ch("checked")).Or <string>(CharGrammar.Ch("class")).Or <string>(CharGrammar.Ch("const")).Or <string>(CharGrammar.Ch("continue")).Or <string>(CharGrammar.Ch("decimal")).Or <string>(CharGrammar.Ch("default")).Or <string>(CharGrammar.Ch("delegate")).Or <string>(CharGrammar.Ch("double")).Or <string>(CharGrammar.Ch("do")).Or <string>(CharGrammar.Ch("else")).Or <string>(CharGrammar.Ch("enum")).Or <string>(CharGrammar.Ch("event")).Or <string>(CharGrammar.Ch("explicit")).Or <string>(CharGrammar.Ch("extern")).Or <string>(CharGrammar.Ch("false")).Or <string>(CharGrammar.Ch("finally")).Or <string>(CharGrammar.Ch("fixed")).Or <string>(CharGrammar.Ch("float")).Or <string>(CharGrammar.Ch("foreach")).Or <string>(CharGrammar.Ch("for")).Or <string>(CharGrammar.Ch("goto")).Or <string>(CharGrammar.Ch("if")).Or <string>(CharGrammar.Ch("implicit")).Or <string>(CharGrammar.Ch("int")).Or <string>(CharGrammar.Ch("in")).Or <string>(CharGrammar.Ch("interface")).Or <string>(CharGrammar.Ch("internal")).Or <string>(CharGrammar.Ch("is")).Or <string>(CharGrammar.Ch("lock")).Or <string>(CharGrammar.Ch("long")).Or <string>(CharGrammar.Ch("namespace")).Or <string>(CharGrammar.Ch("new")).Or <string>(CharGrammar.Ch("null")).Or <string>(CharGrammar.Ch("object")).Or <string>(CharGrammar.Ch("operator")).Or <string>(CharGrammar.Ch("out")).Or <string>(CharGrammar.Ch("override")).Or <string>(CharGrammar.Ch("params")).Or <string>(CharGrammar.Ch("private")).Or <string>(CharGrammar.Ch("protected")).Or <string>(CharGrammar.Ch("public")).Or <string>(CharGrammar.Ch("readonly")).Or <string>(CharGrammar.Ch("ref")).Or <string>(CharGrammar.Ch("return")).Or <string>(CharGrammar.Ch("sbyte")).Or <string>(CharGrammar.Ch("sealed")).Or <string>(CharGrammar.Ch("short")).Or <string>(CharGrammar.Ch("sizeof")).Or <string>(CharGrammar.Ch("stackalloc")).Or <string>(CharGrammar.Ch("static")).Or <string>(CharGrammar.Ch("string")).Or <string>(CharGrammar.Ch("struct")).Or <string>(CharGrammar.Ch("switch")).Or <string>(CharGrammar.Ch("this")).Or <string>(CharGrammar.Ch("throw")).Or <string>(CharGrammar.Ch("true")).Or <string>(CharGrammar.Ch("try")).Or <string>(CharGrammar.Ch("typeof")).Or <string>(CharGrammar.Ch("uint")).Or <string>(CharGrammar.Ch("ulong")).Or <string>(CharGrammar.Ch("unchecked")).Or <string>(CharGrammar.Ch("unsafe")).Or <string>(CharGrammar.Ch("ushort")).Or <string>(CharGrammar.Ch("using")).Or <string>(CharGrammar.Ch("virtual")).Or <string>(CharGrammar.Ch("void")).Or <string>(CharGrammar.Ch("volatile")).Or <string>(CharGrammar.Ch("while"))).NotNext <IList <Snippet>, char>(action14);
ParseAction <IList <Snippet> > identifier = Snip(action15.Unless <string, IList <Snippet> >(keyword)).Or <IList <Snippet> >(Swap <string>(CharGrammar.Ch("class"), "@class")).Or <IList <Snippet> >(Snip <Chain <char, string> >(CharGrammar.Ch('@').And <char, string>(action15), (Func <Chain <char, string>, string>)(hit => ("@" + hit.Down))));
ParseAction <IList <Snippet> > action17 = Snip <Chain <char, string> >(CharGrammar.Ch('.').And <char, string>(action15), (Func <Chain <char, string>, string>)(hit => (hit.Left + hit.Down)));
ParseAction <IList <Snippet> > action18 = Swap <Chain <IList <char>, Chain <Chain <char, IList <char> >, char> > >(Grammar.Opt <IList <char> >(Grammar.Rep <char>(CharGrammar.Ch(new char[] { ' ', '\t' }))).And <IList <char>, Chain <Chain <char, IList <char> >, char> >(CharGrammar.Ch('"').And <char, IList <char> >(Grammar.Rep1 <char>(CharGrammar.ChNot('"'))).And <Chain <char, IList <char> >, char>(CharGrammar.Ch('"')).Or <Chain <Chain <char, IList <char> >, char> >(CharGrammar.Ch('\'').And <char, IList <char> >(Grammar.Rep1 <char>(CharGrammar.ChNot('\''))).And <Chain <char, IList <char> >, char>(CharGrammar.Ch('\'')))), (Func <Chain <IList <char>, Chain <Chain <char, IList <char> >, char> >, string>)(hit => (", \"{0:" + new string(hit.Down.Left.Down.ToArray <char>()) + "}\"")));
ParseAction <IList <Snippet> > lateBound = CharGrammar.Ch('#').And <char, IList <Snippet> >(Snip(action15)).And <Chain <char, IList <Snippet> >, IList <Snippet> >(Snip(Grammar.Rep <IList <Snippet> >(action17))).And <Chain <Chain <char, IList <Snippet> >, IList <Snippet> >, IList <Snippet> >(Grammar.Opt <IList <Snippet> >(action18)).Build <Chain <Chain <Chain <char, IList <Snippet> >, IList <Snippet> >, IList <Snippet> >, IList <Snippet> >(hit => new Snippets("Eval(\"").Concat <Snippet>(hit.Left.Left.Down).Concat <Snippet>(hit.Left.Down).Concat <Snippet>(new Snippets("\"")).Concat <Snippet>((hit.Down ?? ((IList <Snippet>) new Snippet[0]))).Concat <Snippet>(new Snippets(")")).ToList <Snippet>());
ParseAction <IList <Snippet> > action19 = Snip(Grammar.Rep1 <IList <Snippet> >(Swap <string>(CharGrammar.Ch("[["), "<").Or <IList <Snippet> >(Swap <string>(CharGrammar.Ch("]]"), ">")).Or <IList <Snippet> >(lateBound).Or <IList <Snippet> >(Snip(CharGrammar.ChNot(new char[] { '"', '\'', '{', '}', '(', ')' }))).Unless <IList <Snippet>, IList <Snippet> >(identifier.Or <IList <Snippet> >(keyword).Or <IList <Snippet> >(SpecialCharCast)).Unless <IList <Snippet>, string>(CharGrammar.Ch("%>").Or <string>(CharGrammar.Ch("@\"")).Or <string>(CharGrammar.Ch("@'")).Or <string>(CharGrammar.Ch("//")).Or <string>(CharGrammar.Ch("/*")))));
Func <ParseAction <string>, ParseAction <IList <Snippet> > > limitedCodeStretch = limit => Snip(Grammar.Rep1 <IList <Snippet> >(Swap <string>(CharGrammar.Ch("[["), "<").Or <IList <Snippet> >(Swap <string>(CharGrammar.Ch("]]"), ">")).Or <IList <Snippet> >(lateBound).Or <IList <Snippet> >(Snip(CharGrammar.ChNot(new char[] { '"', '\'', '{', '}', '(', ')' }))).Unless <IList <Snippet>, IList <Snippet> >(identifier.Or <IList <Snippet> >(keyword).Or <IList <Snippet> >(SpecialCharCast)).Unless <IList <Snippet>, string>(limit.Or <string>(CharGrammar.Ch("@\"")).Or <string>(CharGrammar.Ch("@'")).Or <string>(CharGrammar.Ch("//")).Or <string>(CharGrammar.Ch("/*")))));
ParseAction <IList <Snippet> > braced = Snip(Snip(CharGrammar.Ch('{')).And <IList <Snippet>, IList <Snippet> >(new ParseAction <IList <Snippet> >(this.FnTerms)).And <Chain <IList <Snippet>, IList <Snippet> >, IList <Snippet> >(Snip(CharGrammar.Ch('}'))));
ParseAction <IList <Snippet> > parens = Snip(Snip(CharGrammar.Ch('(')).And <IList <Snippet>, IList <Snippet> >(new ParseAction <IList <Snippet> >(this.FnTerms)).And <Chain <IList <Snippet>, IList <Snippet> >, IList <Snippet> >(Snip(CharGrammar.Ch(')')))).Unless <IList <Snippet>, IList <Snippet> >(SpecialCharCast);
this.ExpressionTerms = Snip(Grammar.Rep1 <IList <Snippet> >(stringLiteral.Or <IList <Snippet> >(braced).Or <IList <Snippet> >(parens).Or <IList <Snippet> >(action19).Or <IList <Snippet> >(identifier).Or <IList <Snippet> >(keyword).Or <IList <Snippet> >(SpecialCharCast).Or <IList <Snippet> >(oneLineComment).Or <IList <Snippet> >(multiLineComment))).Or <IList <Snippet> >(EmptySnip());
this.LimitedExpressionTerms = limit => Snip(Grammar.Rep1 <IList <Snippet> >(stringLiteral.Or <IList <Snippet> >(braced).Or <IList <Snippet> >(parens).Or <IList <Snippet> >(limitedCodeStretch(limit)).Or <IList <Snippet> >(identifier).Or <IList <Snippet> >(keyword).Or <IList <Snippet> >(SpecialCharCast).Or <IList <Snippet> >(oneLineComment).Or <IList <Snippet> >(multiLineComment))).Or <IList <Snippet> >(EmptySnip());
this.Expression = this.ExpressionTerms.Build <IList <Snippet>, Snippets>(hit => new Snippets(hit));
if (func == null)
{
func = limit => this.LimitedExpressionTerms(limit).Build <IList <Snippet>, Snippets>(hit => new Snippets(hit));
}
this.LimitedExpression = func;
ParseAction <IList <Snippet> > action20 = Swap <string>(CharGrammar.Ch("[["), "<").Or <IList <Snippet> >(Swap <string>(CharGrammar.Ch("]]"), ">")).Or <IList <Snippet> >(lateBound).Or <IList <Snippet> >(Snip(CharGrammar.ChNot(new char[] { '"', '\'' }))).Unless <IList <Snippet>, IList <Snippet> >(SpecialCharCast).Unless <IList <Snippet>, string>(CharGrammar.Ch("@\"").Or <string>(CharGrammar.Ch("@'")).Or <string>(CharGrammar.Ch("//")).Or <string>(CharGrammar.Ch("/*")));
ParseAction <IList <Snippet> > action21 = Snip(Grammar.Rep1 <IList <Snippet> >(action20.Unless <IList <Snippet>, char>(CharGrammar.Ch(new char[] { '\r', '\n' }))));
ParseAction <IList <Snippet> > action22 = Snip(Grammar.Rep1 <IList <Snippet> >(action20.Unless <IList <Snippet>, string>(CharGrammar.Ch("%>"))));
this.Statement1 = Snip(Grammar.Rep <IList <Snippet> >(stringLiteral.Or <IList <Snippet> >(action21).Or <IList <Snippet> >(SpecialCharCast).Or <IList <Snippet> >(oneLineComment).Or <IList <Snippet> >(multiLineComment)));
this.Statement2 = Snip(Grammar.Rep <IList <Snippet> >(stringLiteral.Or <IList <Snippet> >(action22).Or <IList <Snippet> >(SpecialCharCast).Or <IList <Snippet> >(oneLineComment).Or <IList <Snippet> >(multiLineComment)));
}
public void Expected_A_Reduce()
{
var item = new Item(mParenthesizedProduction, 3, Symbol.Of <SymA>());
Run(item, Symbol.EndOfInput, null, ParseAction.MakeDiscard());
Run(item, Symbol.Of <SymLParen>(), null, ParseAction.MakeDiscard());
Run(item, Symbol.Of <SymRParen>(), null, ParseAction.MakeDiscard());
Run(item, Symbol.Of <SymA>(), null, ParseAction.MakeReduce(mParenthesizedProduction));
Run(item, Symbol.Of <Expression>(), null, ParseAction.MakeDiscard());
}
public void Expected_LParen_Shift()
{
var item = new Item(mParenthesizedProduction, 0, Symbol.EndOfInput);
Run(item, Symbol.EndOfInput, null, ParseAction.MakeDiscard());
Run(item, Symbol.Of <SymLParen>(), item.ShiftedByOne(), ParseAction.MakeShift());
Run(item, Symbol.Of <SymRParen>(), null, ParseAction.MakeDiscard());
Run(item, Symbol.Of <SymA>(), null, ParseAction.MakeDiscard());
Run(item, Symbol.Of <Expression>(), null, ParseAction.MakeDiscard());
}
private static ParseAction <string> Str <TValue>(ParseAction <TValue> parser)
{
return(delegate(Position pos) {
ParseResult <TValue> result = parser(pos);
if (result == null)
{
return null;
}
return new ParseResult <string>(result.Rest, pos.Peek(result.Rest.Offset - pos.Offset));
});
}
public static ParseAction <TValue> Paint <TValue, TPaintValue>(ParseAction <TValue> parser) where TValue : TPaintValue
{
return(delegate(Position position) {
ParseResult <TValue> result = parser(position);
if (result == null)
{
return null;
}
return new ParseResult <TValue>(result.Rest.Paint <TPaintValue>(position, (TPaintValue)result.Value), result.Value);
});
}
public static ParseAction <TValue> NotNext <TValue, TValue2>(ParseAction <TValue> parse, ParseAction <TValue2> cond)
{
return(delegate(Position input) {
ParseResult <TValue> result = parse(input);
if ((result != null) && (cond(result.Rest) == null))
{
return result;
}
return null;
});
}
public static ParseAction <TLeft> Left <TLeft, TDown>(this ParseAction <Chain <TLeft, TDown> > parse)
{
return(delegate(Position input) {
ParseResult <Chain <TLeft, TDown> > result = parse(input);
if (result == null)
{
return null;
}
return new ParseResult <TLeft>(result.Rest, result.Value.Left);
});
}
private static ParseAction <IList <Snippet> > Snip <TValue>(ParseAction <TValue> parser, Func <TValue, IList <IList <Snippet> > > combiner)
{
return(delegate(Position position) {
ParseResult <TValue> result = parser(position);
if (result == null)
{
return null;
}
return new ParseResult <IList <Snippet> >(result.Rest, (from s in combiner(result.Value) select s).ToArray <Snippet>());
});
}
private static ParseAction <IList <Snippet> > Snip(ParseAction <IList <IList <Snippet> > > parser)
{
return(delegate(Position position) {
ParseResult <IList <IList <Snippet> > > result = parser(position);
if (result == null)
{
return null;
}
return new ParseResult <IList <Snippet> >(result.Rest, (from s in result.Value select s).ToArray <Snippet>());
});
}
public ParseAction <Node> AsNode <TValue>(ParseAction <TValue> parser) where TValue : Node
{
return(delegate(Position input) {
ParseResult <TValue> result = parser(input);
if (result == null)
{
return null;
}
return new ParseResult <Node>(result.Rest, result.Value);
});
}
public static ParseAction <TValue2> Build <TValue1, TValue2>(this ParseAction <TValue1> parser, Func <TValue1, TValue2> builder)
{
return(delegate(Position input) {
ParseResult <TValue1> result = parser(input);
if (result == null)
{
return null;
}
return new ParseResult <TValue2>(result.Rest, builder(result.Value));
});
}
private string GenerateConsumeAll(ParseAction action)
{
ConsumeAll consume = (ConsumeAll)action;
return
((consume.IsPlural ? "Repeat( () => {\n" : "") +
string.Join("\n",
consume.Actions.Select(next => this.GenerateParseAction(next))
) +
(consume.IsPlural ? "\n});" : ""));
}
private string WrapOptional(ParseAction action, string code)
{
if (!action.IsOptional)
{
return(code);
}
if (this.isTryConsumeString(action))
{
return(code);
}
return("Maybe( () => {\n" + code + "\n});");
}
public CSharpGrammar()
{
var expression = Ch("${").And(Rep1(ChNot('}'))).And(Ch('}'))
.Build(hit => (Node)new ExpressionNode(new string(hit.Left.Down.ToArray())));
var statement = Opt(Ch('\r')).And(Ch('\n')).And(Rep(Ch(char.IsWhiteSpace))).And(Ch("//:")).And(Rep(ChNot('\r','\n')))
.Build(hit => (Node)new StatementNode(new string(hit.Down.ToArray())));
var plaincode = Rep1(Ch(c => true).Unless(statement).Unless(expression)).Build(hit => (Node)new TextNode(hit));
Nodes = Rep(statement.Or(expression).Or(plaincode));
}
public void Expected_Eof_Accept()
{
var item = new Item(
Cfg.ExtendedStartSymbol.MakeProductionFromStartSymbol(Symbol.Of <Expression>()),
1,
Symbol.EndOfInput);
Run(item, Symbol.EndOfInput, null, ParseAction.MakeAccept());
Run(item, Symbol.Of <SymLParen>(), null, ParseAction.MakeDiscard());
Run(item, Symbol.Of <SymRParen>(), null, ParseAction.MakeDiscard());
Run(item, Symbol.Of <Expression>(), null, ParseAction.MakeDiscard());
}
public void Expected_Expr_Shift()
{
var item = new Item(
Cfg.ExtendedStartSymbol.MakeProductionFromStartSymbol(Symbol.Of <Expression>()),
0,
Symbol.EndOfInput);
Run(item, Symbol.EndOfInput, null, ParseAction.MakeDiscard());
Run(item, Symbol.Of <SymLParen>(), null, ParseAction.MakeDiscard());
Run(item, Symbol.Of <SymRParen>(), null, ParseAction.MakeDiscard());
Run(item, Symbol.Of <Expression>(), item.ShiftedByOne(), ParseAction.MakeShift());
}
static ParseAction <IList <Snippet> > Snip(ParseAction <IList <IList <Snippet> > > parser)
{
return(position =>
{
var result = parser(position);
if (result == null)
{
return null;
}
return new ParseResult <IList <Snippet> >(result.Rest, result.Value.SelectMany(s => s).ToArray());
});
}
static ParseAction <IList <Snippet> > Snip <TValue>(ParseAction <TValue> parser, Func <TValue, IList <IList <Snippet> > > combiner)
{
return(position =>
{
var result = parser(position);
if (result == null)
{
return null;
}
return new ParseResult <IList <Snippet> >(result.Rest, combiner(result.Value).SelectMany(s => s).ToArray());
});
}
public static ParseAction <TValue> Paint <TValue, TPaintValue>(ParseAction <TValue> parser) where TValue : TPaintValue
{
return(position =>
{
var result = parser(position);
if (result == null)
{
return null;
}
return new ParseResult <TValue>(result.Rest.Paint <TPaintValue>(position, result.Value), result.Value);
});
}
/// <summary>
/// Uses the first match, as long as the second match does not succeed immediately after the first.
/// </summary>
/// <typeparam name="TValue">The type of the first match.</typeparam>
/// <typeparam name="TValue2">The type of the second match.</typeparam>
/// <param name="parse">The match predicate to be used.</param>
/// <param name="cond">The match predicate that must not match immediately after <paramref name="parse"/>.</param>
/// <returns>The corresponding ParseAction for this match.</returns>
public static ParseAction <TValue> NotNext <TValue, TValue2>(ParseAction <TValue> parse, ParseAction <TValue2> cond)
{
return(delegate(Position input)
{
var result = parse(input);
if (result == null || cond(result.Rest) != null)
{
return null;
}
return result;
});
}
public static ParseAction <IList <TValue> > Rep <TValue>(ParseAction <TValue> parse)
{
return(delegate(Position input) {
List <TValue> list = new List <TValue>();
Position position = input;
for (ParseResult <TValue> result = parse(position); result != null; result = parse(position))
{
list.Add(result.Value);
position = result.Rest;
}
return new ParseResult <IList <TValue> >(position, list);
});
}
static string Parse(ParseAction<string> parser, string content)
{
var result = parser(Source(content));
return result != null ? result.Value : null;
}
/// <summary>
/// Matches a string of characters.
/// </summary>
/// <param name="parse">The predicate of each character to match.</param>
/// <returns>The corresponding ParseAction for this match.</returns>
public static ParseAction<string> StringOf(ParseAction<char> parse)
{
return delegate(Position input)
{
var sb = new StringBuilder();
var rest = input;
var result = parse(rest);
while (result != null)
{
sb.Append(result.Value);
rest = result.Rest;
result = parse(rest);
}
return new ParseResult<string>(rest, sb.ToString());
};
}
public PaintTestGrammar()
{
var notDigit = Rep(ChNot(char.IsDigit).Unless(Ch(char.IsWhiteSpace)))
.Build(hit => new string(hit.ToArray()));
var isDigit = Rep1(Ch(char.IsDigit))
.Build(hit => new string(hit.ToArray()));
DigitPaint = notDigit.And(Paint(isDigit)).And(notDigit)
.Build(hit => new PaintInfo { Before = hit.Left.Left, Thing = hit.Left.Down, After = hit.Down });
ManyPaints = Rep(Opt(Ch(char.IsWhiteSpace)).And(DigitPaint.Paint()).Down());
}
