Java 我的编程语言&x27；s解析器不会在第一个块或第一条语句之后检查任何内容，而while循环只接受一条语句

我用Java编写了一种编程语言。但是，我的解析器有一些问题。解析器只检查第一个块或语句，或者只检查第一个语句，然后停止检查其余已输入的内容。我不太清楚它为什么这样做。这不是注定要这样发生的

在我的编程语言中，while语句也会发生类似的情况。语句只接收一条语句，然后就不再接收了，如果给我一条或多条语句，我的语言将打印出一个错误（不是Java错误，只是一条打印语句，用于我的编程语言的错误处理）。我尝试过使用

do{statement（）；}while（accept（“分号”）和while循环，但这似乎不起作用。我在第一期也尝试了类似的方法，但没有效果

我的目标是让解析器检查不止一个块或语句，并使while循环接受不止一个语句，就像它应该如何根据我的语言语法工作一样。希望你们中的一位能帮助我解决这些问题

标记器：

包dev.fransk.tundra；
导入java.io.File；
导入java.io.FileNotFoundException；
导入java.util.ArrayList；
导入java.util.Scanner；
导入java.util.regex.Matcher；
导入java.util.regex.Pattern；
公共类标记器{
//读取文件
公共静态void readFile（）{
试一试{
File myObj=新文件（“filename.txt”）；
扫描仪myReader=新扫描仪（myObj）；
while（myReader.hasNextLine（））{
String data=myReader.nextLine（）；
系统输出打印项次（数据）；
}
myReader.close（）；
}catch（filenotfounde异常）{
System.out.println（“发生错误”）；
e、 printStackTrace（）；
}
}
//代币
公共静态枚举令牌{
STR（“\”（[^\“]*）\”），IGNORE（“（[^~]*）~”），EXTERN（“EXTERN”），
浮动（“浮动”）、扫描（“扫描”）、字符串（“字符串”），
VOID（“VOID”）、WHILE（“WHILE”）、WRITELN（“WRITELN”）、单词（“[a-zA-Z_]+”），
FLT（“-？[0-9]+\\.[0-9]+”）、LTEQ（“=”）、LT（“）、DEQ（“=”）、NTEQ（“！=”）、MUL（“\\*”），
DIV（“/”），加（\\+”），减（\\-”，
模（“%”）、等式（“=”）、分号（“；”）、LCUR（“\\{”）、RCUR（“\\}”）、跳过（[
\t\f\r\n]+“”，错误（“.”）；
公共最终字符串模式；
令牌（字符串模式）{
这个模式=模式；
}
}
公共静态类词{
公共令牌；
公共字符串词素；
公共字（令牌、字符串词素）{
this.token=token；
this.lexeme=lexeme；
}
@凌驾
公共字符串toString（）{
if（token.name（）=“跳过”）
返回“”；
返回String.format（“%-10s:[%s]”，token.name（），lexeme）；
}
}
公共静态ArrayList lex（字符串输入）{
ArrayList words=新的ArrayList（）；
StringBuffer tokenPatternsBuffer=新StringBuffer（）；
for（令牌：Token.values（））
tokenPatternsBuffer.append（String.format（“|（？%s）”），token.name（），
标记（模式）；
Pattern-tokenPatterns=Pattern.compile（新
字符串（tokenPatternsBuffer.substring（1））；
Matcher Matcher=tokenPatterns.Matcher（输入）；
while（matcher.find（））{
for（令牌：Token.values（））
if（matcher.group（token.name（））！=null）{
添加（新词（token，matcher.group（token.name（）））；
持续
}
}
返回单词；
}
public static ArrayList tokenList=new ArrayList（）；
public static ArrayList lexemlist=new ArrayList（）；
}

以下是解析器类：

包dev.fransk.tundra；
公共类解析器{
公共静态INTI；
专用静态标记器标记器；
公共静态布尔接受（字符串s）{
if（tokenizer.tokenList.get（i）.equals（s））{
i++；
返回true；
}else if（tokenizer.tokenList.get（i）.equals（“EOF”））{
对于（；；）
打破
}
返回false；
}
公共静态布尔期望值（字符串s）{
如果（接受）
返回true；
System.out.println（“解析错误。预期：意外符号”）；
返回false；
}
公共静态空隙系数（）{
如果（接受（“FLT”））
;
否则，如果（接受（“STR”））
;
否则，如果（接受（“词语”））
;
其他的
System.out.println（“解析错误.因子：语法错误”）；
}
公共静态无效项（）{
因子（）；
while（tokenizer.tokenList.get（i）.equals（“PLUS”）||
tokenizer.tokenList.get（i）.equals（“减号”）
||tokenizer.tokenList.get（i）.equals（“MUL”）||
tokenizer.tokenList.get（i）.equals（“DIV”）
||tokenizer.tokenList.get（i）.equals（“模”））{
i++；
因子（）；
}
}
公共静态无效条件（）{
术语（）；
if（tokenizer.tokenList.get（i）.equals（“LT”）||
tokenizer.tokenList.get（i）.equals（“GT”）||
tokenizer.tokenList.get（i）.equals（“LTEQ”）||
tokenizer.tokenList.get（i）.equals（“GTEQ”）||
tokenizer.tokenList.get（i）.equals（“DEQ”）||
tokenizer.tokenList.get（i）.equals（“NTEQ”））{
i++；
术语（）；
}否则
System.out.println（“解析错误。条件：无效运算符”）；
}
公共静态无效语句（）{
如果（接受（“词语”））{
期望（“EQ”）；
术语（）；
expect（“分号”）；
}否则，如果（接受（“外部”））{
期望（“忽略”）；
expect（“分号”）；
public static void factor() {
     if(accept("FLT"))
         ;
     else if(accept("STR"))
         ;
     else if(accept("WORD"))
         ;
     else
         System.out.println("Parsing error. Factor: syntax error");
 }
    

public static void factor1() {
        if (!(accept("FLT") || accept("STR") || accept("WORD"))) {
            System.out.println("Parsing error. Factor: syntax error");
        }
}


private static Tokenizer tokenizer;
    
public static boolean accept(String s) {
    if(tokenizer.tokenList.get(i).equals(s)) {
        i++;
        return true;
    }else if(tokenizer.tokenList.get(i).equals("EOF")) {
        for(;;)
            break;
    }
    return false;
}

public static boolean accept(String s) {
    if(Tokenizer.tokenList.get(i).equals(s)) {
        i++;
        return true;
    }
    return false;
}

 @Override
 public String toString() {
     if (token.name() == "SKIP")
         return "";

     return String.format("%-10s: [%s]", token.name(), lexeme);
 }

    public static void main(String[] args) {
        String input = "float a; a = 3.0; string b; b = \"a\"; extern 
     ~System.out.println(\"e\");~;";
        
        ArrayList<Word> words = tokenizer.lex(input);
        
        for (Word word : words) {
            if(word.token.name() == "ERROR")
                throw new java.lang.Error("Lexing Error: The token \'" + 
    word.lexeme + "\' is invalid");
            
            if(word.token.name() != "SKIP") {
                tokenizer.tokenList.add(String.valueOf(word.token));
                tokenizer.lexemeList.add(String.valueOf(word.lexeme));
            }
        }
        tokenizer.tokenList.add("EOF");
        tokenizer.lexemeList.add("EOF");
        
        System.out.println(tokenizer.tokenList + "\n" + tokenizer.lexemeList);
        parser.program();
    }