Java 递归下降解析器堆栈溢出

我有以下解析器代码，该解析器接受链表作为父类的参数。在我输入表达式后，它抛出堆栈溢出错误

我从Swing GUI类中的jTextField传递输入表达式，然后将布尔结果返回给同一类中的jLabel。什么可能导致堆栈溢出错误？请帮忙，谢谢

输入示例：

1+2+3

（1+2）/（3+4）

import java.util.LinkedList；
类令牌{
公共静态最终整数加上_减=0；
公共静态最终整数乘除=1；
公共静态最终整数指数=2；
公共静态最终整数=3；
公共静态最终整数标识符=4；
公共静态最终int OPEN=5；
公共静态最终int CLOSE=6；
//公共静态最终整数负=7；
public final int token；//每个token保存数据的字段
公共最终字符串序列；
公共令牌（整数令牌、字符串序列）{
超级（）；
this.token=token；
这个序列=序列；
}
}
公共类解析器{
私有令牌下一个；//下一个令牌的指针
私有LinkedList令牌；//令牌生成器生成的令牌列表
专用整数计数器=0；
公共解析器（LinkedList令牌）
{
this.tokens=（LinkedList）tokens.clone（）；//获取LinkedList
this.tokens.getFirst（）；//分配LINKEDLIST的第一个元素
}
////////解析方法的开始////////
/*
语法：
E->E+T | E-T | T |-E
T->T*X | T/X | X
X->X^F | F
F->（E）|编号|标识符
F->（E）| N | I
N->D | ND
I->标识符
*/
公共布尔解析（）
{
返回E（）；//调用开始符号
}
私有布尔项（int标记）//获取下一个标记
{
布尔标志=假；
if（next.token==令牌）
flag=true；
计数器+++；//递增计数器
if（counterE+T | E-T | T |-E////////
私有布尔E（）
{
返回E1（）| E2（）| E3（）；
}
私有布尔E1（）
{
//E->E+T | E-T
int标志=计数器；
布尔结果=真；
if（！（E（）&&term（Token.PLUS_减号）&&T（））
{
计数器=标志；//回溯
if（counterT
int标志=计数器；
布尔结果=真；
如果（！T（））
{
计数器=标志；//回溯
if（counter-E
int标志=计数器；
布尔结果=真；
if（！（术语（标记加减）和&E（））
{
计数器=标志；//回溯
if（counterT*X | T/X | X////////
私有布尔T（）
{
返回T1（）| T2（）；
}
私有布尔T1（）
{
//T->T*X | T/X
int标志=计数器；
布尔结果=真；
if（！（T（）&&term（Token.MULTIPLY\u DIVIDE）&&X（））
{
计数器=标志；//回溯
if（counterX
int标志=计数器；
布尔结果=真；
如果（！X（））
{
计数器=标志；//回溯
if（counterX^F | F////////
私有布尔X（）
{
返回X1（）| X2（）；
}
私有布尔X1（）
{
//X->X^F
int标志=计数器；
布尔结果=真；
if（！（X（）&&term（Token.EXPONENT）&&F（））
{
计数器=标志；//回溯
if（counterF
int标志=计数器；
布尔结果=真；
如果（！F（））
{
计数器=标志；//回溯
if（counter（E）|编号|标识符////////
私有布尔F（）
{
返回F1（）| | F2（）| | F3（）；
}
私有布尔F1（）
{
//F->（E）
int标志=计数器；
布尔结果=真；
if（！（term（Token.OPEN）和&E（）&&term（Token.CLOSE）））
{
计数器=标志；//回溯
if（counter数字
int标志=计数器；
布尔结果=真；
如果（！术语（标记号））
{
计数器=标志；//回溯
if（counterimport java.util.LinkedList;

class Token {
    public static final int PLUS_MINUS = 0;
    public static final int MULTIPLY_DIVIDE = 1;
    public static final int EXPONENT = 2;
    public static final int NUMBER = 3;
    public static final int IDENTIFIER = 4;
    public static final int OPEN = 5;
    public static final int CLOSE = 6;
    //public static final int NEGATIVE = 7;

    public final int token; // FIELDS TO HOLD DATA PER TOKEN
    public final String sequence;

    public Token (int token, String sequence) {
        super();
        this.token = token;
        this.sequence = sequence;
    }
}

public class Parser {

    private Token next; // POINTER FOR NEXT TOKEN
    private LinkedList<Token> tokens; // LIST OF TOKENS PRODUCED BY TOKENIZER
    private int counter = 0;

    public Parser(LinkedList tokens) 
    {
        this.tokens = (LinkedList<Token>) tokens.clone(); // GET LINKEDLIST
        this.tokens.getFirst(); // ASSIGNS FIRST ELEMENT OF LINKEDLIST
    }


    //////// START OF PARSING METHODS ////////

    /*
        GRAMMAR:
        E -> E+T | E-T | T | -E
        T -> T*X | T/X | X
        X -> X^F | F
        F -> (E) | NUMBERS | IDENTIFIERS
                        F -> (E) | N | I
                        N -> D | ND
                        I -> IDENTIFIERS
    */

    public boolean Parse ()
    {
        return E(); // INVOKE START SYMBOL
    }

    private boolean term (int token) // GETS NEXT TOKEN
    {
        boolean flag = false;

        if(next.token == token)
            flag = true;

        counter++; // INCREMENT COUNTER

        if(counter < tokens.size()) // POINT TO NEXT TOKEN
            next = tokens.get(counter);

        return flag;
    }

    ///////// START OF LIST OF PRODUCTIONS /////////

    //////// E -> E+T | E-T | T | -E ////////

    private boolean E() 
    {
        return E1() || E2() || E3();
    }

    private boolean E1 ()
    {
        // E -> E+T | E-T

        int flag = counter;
        boolean result = true;

        if(!(E() && term(Token.PLUS_MINUS) && T() ))
        {
            counter = flag; // BACKTRACK

            if(counter < tokens.size()) // POINT TO PREVIOUS TOKEN
                next = tokens.get(counter);

            result = false;
        }
        return result;
    }

    private boolean E2 ()
    {
        // E -> T

        int flag = counter;
        boolean result = true;

        if(!T())
        {
            counter = flag; // BACKTRACK

            if(counter < tokens.size()) // POINT TO PREVIOUS TOKEN
                next = tokens.get(counter);

            result = false;
        }
        return result;
    }

    private boolean E3 ()
    {
        // E -> -E

        int flag = counter;
        boolean result = true;

        if(!(term(Token.PLUS_MINUS) && E() ))
        {
            counter = flag; // BACKTRACK

            if(counter < tokens.size()) // POINT TO PREVIOUS TOKEN
                next = tokens.get(counter);

            result = false;
        }
        return result;
    }


    //////// T -> T*X | T/X | X ////////

    private boolean T()
    {
        return T1() || T2();
    }

    private boolean T1 ()
    {
        // T -> T*X | T/X

        int flag = counter;
        boolean result = true;

        if(!(T() && term(Token.MULTIPLY_DIVIDE) && X() ))
        {
            counter = flag; // BACKTRACK

            if(counter < tokens.size()) // POINT TO PREVIOUS TOKEN
                next = tokens.get(counter);

            result = false;
        }
        return result;
    }

    private boolean T2 ()
    {
        // T -> X

        int flag = counter;
        boolean result = true;

        if(!X())
        {
            counter = flag; // BACKTRACK

            if(counter < tokens.size()) // POINT TO PREVIOUS TOKEN
                next = tokens.get(counter);

            result = false;
        }
        return result;
    }


    //////// X -> X^F | F ////////

    private boolean X()
    {
        return X1() || X2();
    }

    private boolean X1()
    {
        // X-> X^F

        int flag = counter;
        boolean result = true;

        if(!(X() && term(Token.EXPONENT) && F()))
        {
            counter = flag; // BACKTRACK

            if(counter < tokens.size()) // POINT TO PREVIOUS TOKEN
                next = tokens.get(counter);

            result = false;
        }
        return result;
    }

    private boolean X2()
    {
        // X-> F

        int flag = counter;
        boolean result = true;

        if(!F())
        {
            counter = flag; // BACKTRACK

            if(counter < tokens.size()) // POINT TO PREVIOUS TOKEN
                next = tokens.get(counter);

            result = false;
        }
        return result;
    }


    //////// F -> (E) | NUMBERS | IDENTIFIERS ////////
    private boolean F()
    {
        return F1() || F2() || F3();
    }

    private boolean F1()
    {
        // F -> (E)

        int flag = counter;
        boolean result = true;

        if(!(term(Token.OPEN) && E() && term(Token.CLOSE)))
        {
            counter = flag; // BACKTRACK

            if(counter < tokens.size()) // POINT TO PREVIOUS TOKEN
                next = tokens.get(counter);

            result = false;
        }
        return result;
    }

    private boolean F2()
    {
        // F -> NUMBERS

        int flag = counter;
        boolean result = true;

        if(!term(Token.NUMBER))
        {
            counter = flag; // BACKTRACK

            if(counter < tokens.size()) // POINT TO PREVIOUS TOKEN
                next = tokens.get(counter);

            result = false;
        }
        return result;
    }

    private boolean F3()
    {
        // F -> IDENTIFIERS

        int flag = counter;
        boolean result = true;

        if(!term(Token.IDENTIFIER))
        {
            counter = flag; // BACKTRACK

            if(counter < tokens.size()) // POINT TO PREVIOUS TOKEN
                next = tokens.get(counter);

            result = false;
        }
        return result;
    }
}

public boolean Parse() {
    return E(); // INVOKE START SYMBOL
}

private boolean E() {
    return E1() || E2() || E3();
}

private boolean E1 () {
    // E -> E+T | E-T

    int flag = counter;
    boolean result = true;
    if(!(E() && term(Token.PLUS_MINUS) && T() )) {
        counter = flag; // BACKTRACK
    ...