Shulou(Shulou.com)06/02 Report--

Xiaobian to share with you what C#Parsing Library means, I believe most people still do not know how, so share this article for your reference, I hope you have a lot of harvest after reading this article, let's go to understand it together!

C#Parsing Library is an LL parser generation framework that emulates ENBF grammar definitions in C#. The design idea comes from Boost.Spirit, a C++ parser framework.

C#Parsing Library: Basic Parser Concepts

a) Grammar definition example: P ::= a b C#Usage: P = a + b sequence

b) Example of grammar definition: P ::= a| b C#Usage: P = a| B select

c) Example of grammar definition: P ::= a * C#Usage: P = a.Star 0.. n times matching

d) Example of grammar definition: P ::= a + C#Usage: P = a.Plus 1.. n times matching

e) Grammar definition example: P ::= a ? C#Usage: P = a.Opt 0.. 1 Match

P is a Parser type, an abstract base class for parsers, which defines an abstract Parse method:

bool Parse(Scanner scanner);

The Scanner class basically stores a string input and a cursor position, and the cursor moves forward as the parse proceeds.

Example: An integer resolver, defined as an optional symbol followed by several numbers:

Parser signed = (Parser.Lit('+') | '-').Opt; Parser p = (signed + Parser.DigitChar.Plus).Lexeme; bool success = p.Parse(new Scanner("-123"));

Where Lit represents constant and Lexeme represents lexical analysis, i.e. spaces are not ignored.

C# Parsing Library: ParserRef

A common grammar of four operational expressions:

group ::= '(' expression ')' factor ::= integer | group term ::= factor (('*' factor) | ('/' factor))* expression ::= term (('+' term) | ('-' term))*

It is wrong to use the following method:

Parser group; // Parser is abstract class, cannot new Parser factor; factor = Parser.Int| group; //error! group is not initialized!

However, ParserRef can be used:

ParserRef group = new ParserRef(); ParserRef factor = new ParserRef(); factor.Parser = Parser.Int | group;

The complete definition is as follows:

ParserRef group = new ParserRef(); ParserRef factor = new ParserRef(); ParserRef term = new ParserRef(); ParserRef expression = new ParserRef(); group.Parser = '(' + expression + ')'; factor.Parser = Parser.Int | group; term.Parser = factor + ( ('*' + factor) | ('/' + factor) ).Star; expression.Parser = term + ( ('+' + term) | ('-' + term) ).Star;

C#Parsing Library: Rule and Semantic Support

As with spirit, support for semantics is achieved by overloading []. The Action type of a parser is Action.

void Action(string s). s is the content matched by the parser. If you want to support context, you have to use Rule. Rule takes a template parameter T, which indicates the attribute type. Action type is Func

T Action(T lhs, T rhs). For the following simple rules:

LeftRule := RightRule [ Action(lhs, rhs) ]

Its semantics are: LeftRule.Attribute = Action(LeftRule.Attribute, RightRule.Attribute).

The above example of four operations can be modified as follows:

Grammar

grammar = new Grammar

(); Rule

group = new Rule

(grammar); Rule

factor = new Rule

(grammar); Rule

term = new Rule

(grammar); Rule

expression = new Rule

(grammar); Rule

start = new Rule

(grammar); grammar.Start = start; group.Parser = '(' + expression [ (lhs, rhs) => rhs ] + ')'; factor.Parser = Parser.IntValue [ v => grammar.Ret(v) ] // (#1) | group [ (lhs, rhs) => rhs ]; term.Parser = factor [ (lhs, rhs) => rhs ] + ( ('*' + factor [ (lhs, rhs) => lhs * rhs ]) | ('/' + factor [ (lhs, rhs) => lhs / rhs ]) ).Star; expression.Parser = term [ (lhs, rhs) => rhs ] + ( ('+' + term [ (lhs, rhs) => lhs + rhs ]) | ('-' + term [ (lhs, rhs) => lhs - rhs ]) ).Star; start.Parser = expression [ (lhs, rhs) => rhs ] + Parser.End; int result; bool success = grammar.Parse("10 + 20 + 30 * (40 + 50)", out result); if (success) Console.WriteLine(result);

Description:

For a normal Parser, the semantic action cannot have a return value because it does not know the exact type of the attribute. To support attributes, you must use Grammar.Ret().

Before I implemented it myself, I roughly searched it, and there is a similar implementation on CodeProject, which also imitates Boost.Spirit, but its semantic processing uses C#event mechanism, which is extremely inconvenient to use.

The above is all the content of this article "C#Parsing Library", thank you for reading! I believe that everyone has a certain understanding, hope to share the content to help everyone, if you still want to learn more knowledge, welcome to pay attention to the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.