如何将EBNF重复实现为Java代码？

我正在用Java编写一个简单的递归体面解析器，它使用词法分析器将源代码从一个假设的命令式编程语言（看起来有点像伪代码）从一个文本文件中拆分为单个标记，然后检查这些标记是否遵循EBNF语法的规则。如果不遵循规则，程序将输出存在语法错误（而不是它是什么或发生在哪里）

以下是EBNF语法：

<program> -> program begin <statement_list> end
<statement_list> -> <statement> {;<statement>}
<statement> -> <assignment_statement> | <if_statement> | <loop_statement> 
<assignment_statement> -> <variable> = <expression>
<variable> -> identifier (An identifier is a string that begins with a letter followed by 0 or more letters and/or digits)
<expression> -> <term> {(+|-) <term>}           
<term> -> <factor> {(* | /) <factor>}
<factor> -> identifier | int_constant | (<expr>)
<if_statement> -> if (<logic_expression>) then <statement> 
<logic_expression> -> <variable> (< | >) <variable> (Assume logic expressions have only less than or greater than operators)
<loop_statement> -> loop (<logic_expression>) <statement>

---

任何帮助都将不胜感激。

大括号的作用是接受0个或更多的项目。这通常被实现为循环，即，当当前令牌是可以启动当前序列的令牌时，处理该序列。（注意，psudo代码在前面）：

这是什么“

FIRSTS

”？这是一组预先计算好的令牌，可能会启动您当前正在分析的序列。例如，

FIRSTS（；）

是“；”

lookAhead

是lexer/scanner中的一个函数，它返回当前令牌（而不使用它）

一般来说，序列的第一个集合不能包含该序列的后续集合中存在的任何标记。FOLLOW是该序列之后可能出现的一组标记

幸运的是，语法中的三个重复块的第一个集合与它们的跟随集合是不同的。名字，序列的第一个

是
['；']
，序列的第一个
（+）
是
['+'，'-']
，序列的第一个
（*|/）
是
['*'，'/']

这只是为每个块实现该算法的问题。
大括号的效果是接受它们所包含的序列中的0个或多个项。这通常被实现为循环，即，当当前令牌是可以启动当前序列的令牌时，处理该序列。（注意，psudo代码在前面）：

这是什么“
FIRSTS
”？这是一组预先计算好的令牌，可能会启动您当前正在分析的序列。例如，
FIRSTS（；）
是“；”

lookAhead
是lexer/scanner中的一个函数，它返回当前令牌（而不使用它）

一般来说，序列的第一个集合不能包含该序列的后续集合中存在的任何标记。FOLLOW是该序列之后可能出现的一组标记

幸运的是，语法中的三个重复块的第一个集合与它们的跟随集合是不同的。名字，序列的第一个
是
['；']
，序列的第一个
（+）
是
['+'，'-']
，序列的第一个
（*|/）
是
['*'，'/']

这只是为每个块实现算法的问题。
这里的
扫描器
完全没有意义，浪费时间和空间。与你的问题无关。重复只是在递归下降中循环的问题。不清楚你在问什么。这里的
扫描仪
完全没有意义，浪费时间和空间。与你的问题无关。重复只是在递归下降中循环的问题。不清楚你在问什么。这很有帮助！这个概念现在对我来说非常有意义。我知道我需要使用某种类型的lookAhead（），所以直觉是存在的，但由于这是我第一次接触解析器，我不知道如何去做。谢谢男人：）这帮了大忙！这个概念现在对我来说非常有意义。我知道我需要使用某种类型的lookAhead（），所以直觉是存在的，但由于这是我第一次接触解析器，我不知道如何去做。谢谢男人：）
program
begin

sum1 = var1 + var2;
sum2 = var3 + var2 * 90;
sum3 = (var2 + var1) * var3;

if (sum1 < sum2) then
    if (var1 > var2) then
        var4 = sum2 - sum1;

loop (var1 < var2)
    var5 = var4/45

end

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.StringTokenizer;

public class SyntacticAnalysis {

    private static class Parser {

        // Parser has buffer -- which contains the source code as text -- it must read from
        private StringBuilder buffer;

        public Parser(File file) {

            // Reading from text file using simple scanner
            Scanner sc = null;

            try {

                sc = new Scanner(file);

                // Define buffer length as file length
                buffer = new StringBuilder((int)file.length());

                // Stops reading when no more text
                while(sc.hasNext()) {

                    // Token will be sequence of characters
                    String token = sc.next();

                    // Since token character sequence may contain characters such as ()+-*/=;
                    // We need to further break down token to separate special character and rest
                    // E.g. if(sum1<sum2) token will be further tokenized into: if ( sum1 < sum2 )
                    // This way spacing doesn't matter  
                    StringTokenizer tokens = new StringTokenizer(token, "()+-*/=;", true);

                    // Add tokens to buffer
                    while (tokens.hasMoreTokens())
                        buffer.append(tokens.nextToken() + " ");

                }


            } catch (FileNotFoundException fnfe) {

                System.out.print("File not found.");
                fnfe.printStackTrace();

            } finally {

                sc.close();

            }

        }

        private String lexicalAnalyzer() {

            int i = buffer.indexOf(" ");

            // Lexeme will be from beginning of buffer (location of current token) to where whitespace is
            String lexeme = buffer.substring(0, i);

            // Delete lexeme from buffer since now stored in variable
            buffer.delete(0, i + 1);

            // Print what tokens are read for debugging purposes
            System.out.println(lexeme);

            return lexeme;

        }

        // Method for main
        // Returns program() since <program> -> program begin <statement_list> end is checked first
        public boolean analyzeCode() {

            return program();

        }

        private boolean program() {

            // Every program must have program followed by begin
            if (!lexicalAnalyzer().toLowerCase().equals("program")) return false;
            if (!lexicalAnalyzer().toLowerCase().equals("begin")) return false;

            if (!statementList()) return false;

            // Every program must finish with end keyword
            if (!lexicalAnalyzer().equals("end")) return false;

            return true;

        }

        private boolean statementList() {

            if (!statement()) return false;

            /* Repetition to check further statements goes here -- how to implement? */

            return true;

        }

        private boolean statement() {

            // Define statement as variable for now just as a test
            if (!variable()) return false;

            return true;

        }

        private boolean variable() {

            // Regular expression to determine valid identifier
            // [a-zA-Z] means starts with any letter
            // [a-zA-Z0-9]* means any amount of alphanumeric characters (0 - infinity)
            if (!lexicalAnalyzer().matches("[a-zA-Z][a-zA-Z0-9]*")) return false;

            return true;

        }

    }

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.print("Enter file name: ");

        String name = sc.next();

        File file = new File(name);

        Parser parser = new Parser(file);

        if (parser.analyzeCode())
            System.out.print("There are no syntax errors in the program.");
        else
            System.out.print("The program contains one or more syntax errors.");

    }

}

    while(FIRSTS contain lookAhead()){
      processCurrentBlock()
    }