将BNF语法转换为Java

Question

How can I convert this simple (recursive) grammar to Java?

C --> a | not C | C and C | C or C ;

This question is not meant what tool I have to use to parse a grammar (like Javacc or Antlr), but the way to model this simple grammar using the object-oriented paradigm.

Answer 1

This is a very broad question to answer without actually mentioning specific tools as your implementation of any grammar could happen in a huge number of ways depending on which language you choose to implement your parser in...if you look at the source of tools such as the ones you mentioned ANTLR and Javacc it will reveal how others implemented their tools and the techniques they used to develop top down parsers etc but just because thats how they implemented theirs does not mean its necessarily the only way.

The BNF is used only for giving a formal way of describing the structure of the language:

They are applied wherever exact descriptions of languages are needed: for instance, in official language specifications, in manuals, and in textbooks on programming language theory.

As they are only used to give a break down of what is expected from input its up to the programmer to decide how that is implemented with the language tools and api's available to them whether it be regex's in java or string searches or tokenizing provided by another language its unfortunately entirely your choice to decide thenless you are working with a tool specifically for generating a parser for your language at which point we could answer this question if it makes sense.

Answer 2

I don't think there's a single way to model this using OOP and that there are many equally valid ways you could go about approaching this. The following is one reasonable strategy for thinking about what this might look like in code.

Usually, when parsing an expression, your goal is to reconstruct an abstract syntax tree for the input. That tree structure has different types of nodes based on the different productions that are possible, and in Java you'd probably represent them with some polymorphic type. For example, you might have a base class ASTNode that has children ANode , NotNode , AndNode , and OrNode . These last three types would store pointers to the subexpressions that make up the compound expression.

Once you have these types, you'd then need to put together some sort of parser - and possibly a scanner - that would take the input and construct the appropriate tree from it. Since you're looking at a grammar that consists of different operators with different precedences, you could use a simple precedence parser like Dijkstra's shunting-yard algorithm to do the parsing. That algorithm is relatively straightforward to implement.

At that point it really depends on what you want to do with the AST. If you want to evaluate the expression depending on what inputs are provided, for example, you could add an abstract method evaluate to the ASTNode type and then have each derived type provide an implementation that performs the appropriate operation. You could also consider using the visitor pattern to build visitors that walk the AST and perform appropriate operations at each step.

I'm not sure whether this would be helpful, but a while back I wrote something very similar to what you're looking at to generate truth tables for propositional logic for a class I often teach. The tool itself is available here , and the source files, which are decently well-commented, are available here . It's written in JavaScript rather than Java, but it shows off all the pieces described above - the AST node type, the shunting-yard algorithm to do parsing, and overridden methods to evaluate the different expressions.