【编译技术】LL(1)实现递归下降分析法

本代码是针对以下文法的

//E->TE'
//E'->+TE'|e
//T->FT'
//T'->*FT'|e
//F->(E)|id

以下是该文法的first集合，follow集合与预测分析表

//E->TE'        first(E) = { (, id }    follow(E) = { ) }
//E'->+TE'|e    first(E') = { +, e }    follow(E') = { ) }
//T->FT'        first(T) = { (, id }    follow(T) = { +, ) }
//T'->*FT'|e    first(T') = { *, e }    follow(T') = { +, ) }
//F->(E)|id     first(F) = { (, id }    follow(F) = { *, +, ) }

//预测分析表
//      +           *           (           )           id
//E                             E->TE'                  E->TE'
//E'    E'->+TE'                            E'->e
//T                             T->FT'                  T->FT'
//T'    T'->e       T'->*FT'                T'->e
//F                             F->(E)                  F->id

输入格式：串中的终止符需要以空格分开，并以$符号结尾

输入样例：
id + id * id $
.
.
.
.
以下为代码

import java.util.*;

public class LL1 {
    static String [] str = null;
    static int now = 0;

    //所有函数，失败返回0，成功返回1
    static int E(){
        if(now>=str.length){
            System.out.println("错误：E推导时出错，缺少 ( 或 id");
            return 0;
        }
        else if(str[now].equals("(")||str[now].equals("id")){
            System.out.println("执行：E->TE'");
            return T()*E1();
        }
        System.out.println("错误：E推导时出错，此时只有 ( 或 id 能够被匹配");
        return 0;
    }


    static int E1(){
        if(now>=str.length){
            System.out.println("错误：E'推导时出错，缺少 + 或 )");
            return 0;
        }
        else if(str[now].equals("+")){
            System.out.println("执行：E'->+TE'");
            now++;
            return T()*E1();
        }
        else if(str[now].equals("$")){
            System.out.println("执行：E'->e");
            return 1;
        }
        System.out.println("错误：E'推导时出错，此时只有 + 或 ) 能够被匹配");
        return 0;
    }


    static int T(){
        if(now>=str.length){
            System.out.println("错误：T推导时出错，缺少 ( 或 id");
            return 0;
        }
        else if(str[now].equals("(")||str[now].equals("id")){
            System.out.println("执行：T->FT'");
            return F()*T1();
        }
        System.out.println("错误：T推导时出错，此时只有 ( 或 id 能够被匹配");
        return 0;
    }


    static int T1(){
        if(now>=str.length){
            System.out.println("错误：T'推导时出错，缺少 +, * 或 )");
            return 0;
        }
        else if(str[now].equals("*")){
            System.out.println("执行：T'->*FT'");
            now++;
            return F()*T1();
        }
        else if(str[now].equals("+")){
            System.out.println("执行：T'->e");
            return 1;
        }
        else if(str[now].equals("$")){
            System.out.println("执行：T'->e");
            return 1;
        }
        System.out.println("错误：T'推导时出错，此时只有 +，* 或 ） 能够被匹配");
        return 0;
    }


    static int F(){
        if(now>=str.length){
            System.out.println("错误：F推导时出错，缺少 ( 或 id");
            return 0;
        }
        else if(str[now].equals("id")){
            System.out.println("执行：F->id");
            now++;
            return 1;
        }
        else if(str[now].equals("(")){
            System.out.println("执行：F->(E)");
            now++;
            int ttt = E();
            if(ttt==0){
                return 0;
            }
            else if(str[now].equals(")")){
               now++;
               return 1;
            }
            else{
                System.out.println("错误：F推导时出错，缺少 )");
                return 0;
            }
        }
        System.out.println("错误：F推导时出错，此时只有 ( 或 id 能够被匹配");
        return 0;
    }

    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        String ins = scanner.nextLine();
        str = ins.split(" ");
        int t = E();
        if(t==0){
            System.out.println("\n推导因错误而终止");
        }
        else{
            System.out.println("\n推导结束");
        }
    }

}