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