एक बार फिर से पुनरावर्ती वंश विधि का उपयोग कर अभिव्यक्तियों के विश्लेषण के बारे में

ई -> टी + ई | टी - ई | टी
टी -> एफ * टी | एफ / टी | एफ
एफ -> एन | (इ)

2 + 3 * (4 - 5) + 6 - 7

ई (2 + 3 * (4-5) + 6-7) -> 
टी (2) + ई (3 * (4-5) + 6-7) -> 
टी (2) + टी (3 * (4-5)) + ई (6-7) -> 
T (2) + T (3 * (4-5)) + T (6) - T (7)

T (2) -> F (2)
T (3 * (4-5)) -> F (3) * T ((4-5)) -> F (3) * F ((4-5))
टी (6) -> एफ (6)
T (7) -> F (7)

एफ (2) -> एन (2) -> 2
एफ (3) -> एन (3) -> 3
एफ (4-5)) -> ई (4-5)
एफ (6) -> एन (6) -> 6
एफ (7) -> एन (7) -> 7

ई -> टी ± टी ± टी> टी ± ...। टी

टी -> एफ * / एफ * / एफ * / * / ... * / एफ

String[] tokens = {"2", "+", "3", "*", "(", "4", "-", "5", ")", "+", "6", "-", "7"};

• पार्स () एक अभिव्यक्ति को पार्स करना शुरू कर देता है
• अभिव्यक्ति () प्रकार ई की अभिव्यक्तियों को संभालने के लिए
• टी के प्रकार के प्रसंस्करण के लिए शब्द ()
• एफ और एन प्रकार के प्रसंस्करण के लिए कारक ()

public class RecursiveDescentParser {

    private final String[] tokens;
    private int pos = 0; //   

    public RecursiveDescentParser(String[] tokens) {
        this.tokens = tokens;
    }

    public Double parse() {
        Double result = expression();
        if (pos != tokens.length) {
            throw new IllegalStateException("Error in expression at " + tokens[pos]));
        }
        return result;
    }

    // E -> T±T±T±T± ... ±T
    private Double expression() {
        //   
        Double first = term();

        while (pos < tokens.length) {
            String operator = tokens[pos];
            if (!operator.equals("+") && !operator.equals("-")) {
                break;
            } else {
                pos++;
            }

            //    ()
            Double second = term();
            if (operator.equals("+")) {
                first += second;
            } else {
                first -= second;
            }
        }
        return first;
    }

    // T -> F*/F*/F*/*/ ... */F
    private Double term() {
        //   
        Double first = factor();

        while (pos < tokens.length) {
            String operator = tokens[pos];
            if (!operator.equals("*") && !operator.equals("/")) {
                break;
            } else {
                pos++;
            }

            //    ()
            Double second = factor();
            if (operator.equals("*")) {
                first *= second;
            } else {
                first /= second;
            }
        }
        return first;
    }
    
    // F -> N | (E)
    private Double factor() {
        String next = tokens[pos];
        Double result;
        if (next.equals("(")) {
            pos++;
            //    ,        
            result = expression();  
            String closingBracket;
            if (pos < tokens.length) {
                closingBracket = tokens[pos];
            } else {
                throw new IllegalStateException("Unexpected end of expression");
            }
            if (pos < tokens.length && closingBracket.equals(")")) {
                pos++;
                return result;
            }
            throw new IllegalStateException("')' expected but " + closingBracket);
        }
        pos++;
        //       
        return Double.parseDouble(next);
    }
}