任务描述

本关任务：根据某一文法编制调试递归下降分析程序，以便对任意输入的符号串进行分析。

相关知识

为了完成本关任务，你需要掌握：递归下降分析程序设计与实现。

递归分析法

递归下降分析法，顾名思义就是使用递归的思想去分析。对于一个文法G，对其每一个非终结符U构造一个递归过程，一般的，以非终结符的名字来命名这个子过程。所有子程序构造完成后，对指定文法，运行文法开始符号对应的子程序，返回匹配结果。

递归下降分析法是一种简洁的分析方法，对于给定的文法G。

1. S -> N V N
2. N -> s
3. | t
4. | g
5. | w
6. V -> e
7. | d

可以根据S的产生式，得到 N,V,N 三个非终结符的子程序，在子程序中，可以分别对N,V,N进行相关的定义：

1. parse_S()
2. parse_N()
3. parse_V()
4. parse_N()
6. parse_N()
7. token = tokens[i++]
8. if(token == s || token == t || token == g || token == w)
9. return;
10. error("...")
12. parse_V()
13. token = tokens[i++]
14. ... //

同样的，如果N，V的产生式中还具有非终结符，我们便可以继续递归，完成文法的G的分析。

实验步骤

根据上述可知，在使用递归分析法完成语法分析时，需要做到：

• 对语法规则有明确的定义；
  在递归分析法中，文法由程序之间的相互调用形成递归而构成，我们需要在每个子程序中给出该符号的相关选择就可以了，例如，对于某一符号X，可以给出如下的定义：
  1. void X()
  2. {
  3. if (str[index] == '+')
  4. {
  5. index++;
  6. T();
  7. X();
  8. }
  9. }
• 编写的分析程序能够进行正确的语法分析；
• 对于遇到的语法错误，能够做出简单的错误处理，给出简单的错误提示，保证顺利完成语法分析过程；

编程要求

根据提示，在右侧编辑器Beign和End之间补充判断为+或者-号、判断*号和/号、判断字符和（）的代码，点击测评，运行程序，进行结果对比。

根据下列文法完成程序设计，并给出相应提示：

1. （1）E- TG
2. （2）G- +TG|—TG
3. （3）G- ε
4. （4）T- FS
5. （5）S- *FS|/FS
6. （6）S- ε
7. （7）F- (E)
8. （8）F- i

输出的格式如下： 程序会自动读取预设的输入完成类似的输出：

1. 请在键盘键入表达式：(以#号结束)
2. i+i/i#
3. +i/i#
4. i/i#
5. /i#
6. i#
7. #
8. 表达式正确！

测试说明

---

开始你的任务吧，祝你成功！

代码：

    import java.io.*;
    import java.util.Scanner;
     
    public class ex3 {
        
        public static String buffer = null;//存取从键盘输入的字符
        public static int p = 0;//字符当前的位置
        public static String ch;//存取当前字符
        public static boolean error = false;//判断表达式是否正确
        public static int m = 0;
        /*******Beign*******/
        /*判断是否为+或者-号*/
        public boolean plusandminus()//
        {
            boolean flag = false;
            multiplyanddivide();//*号和/号的判断
            if(ch.equals("+") || ch.equals("-"))
            {
                flag = true;
            }
            if(flag)
            {
                p = p + 1;
                ch = buffer.substring(p,p+1);
                //System.out.println("(plusandminus)ch:"+ch);
                outputspace(p+1,m);
                plusandminus();
            }
            return flag;
        }
        /********End********/
        /*******Beign*******/
        /*判断*号和/号*/
        public boolean multiplyanddivide()//
        {
            boolean flag = false;
            brackets();//字符和（）的判断
            if(ch.equals("*") || ch.equals("/"))
            {
                flag = true;
            }
            if(flag)
            {
                p = p + 1;
                ch = buffer.substring(p,p+1);
                //System.out.println("(multiplyanddivide)ch:"+ch);
                outputspace(p+1,m);
                multiplyanddivide();
            }
            return flag;
        }
        /********End********/
        /*******Beign*******/
        /*字符和”（）“的判断*/
        public boolean brackets()//
        {
            boolean flag = false;
            if(ch.compareTo("A") >= 0 && ch.compareTo("Z") <= 0)
            {
                flag = true;
            }
            if(ch.compareTo("a") >= 0 && ch.compareTo("z") <= 0)
            {
                flag = true;
            }
            if(flag)//是否为字符
            {
                p = p + 1;
                ch = buffer.substring(p,p+1);
                //System.out.println("(isstring1)ch:"+ch);
                outputspace(p+1,m);
                return flag;
            }
            else if(ch.equals("("))//是否为“（”符号
            {
                p = p + 1;
                ch = buffer.substring(p,p+1);
                //System.out.println("(isstring2)ch:"+ch);
                outputspace(p+1,m);
                plusandminus();//判断括号里的表达式是否正确
                if(ch.equals(")"))//是否有配对的“）”
                {
                    p = p + 1;
                    ch = buffer.substring(p,p+1);
                    //System.out.println("(isstring3)ch:"+ch);
                    outputspace(p+1,m);
                }
                else
                {
                    error = true;
                }
            }
            else
            {
                error = true;
            }
            return flag;
        }
        /********End********/
        public void outputspace(int n,int m)//输出空格
        {
            StringBuffer buf = new StringBuffer();
            for(int i = 0;i < n;i++)
            {
                buf.append(" ");
            }
            if(n<m)
            {
                System.out.print(buf.toString());
                System.out.println(buffer.substring(p+1,m));
            }
        }
        
        public void mainoperation(int n,int a) throws IOException//读取输入字符，如果出错，抛出IO异常
        { 
            p = 0;
            boolean flag = true;
            System.out.println("请在键盘键入表达式：(以#号结束)");
            BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));//定义输入流
            buffer = buf.readLine();//读取一行字符
            System.out.println(buffer);
            m=buffer.length();
            while(flag)
            {
                ch = buffer.substring(p,p+1);
                outputspace(p+1,m);
                if(ch.equals("#") || error)//判断是否结束
                {
                    flag = false;
                    break;
                }
                plusandminus();//子程序判断表达式是否正确
            }
            if(error)
            {
                System.out.println("表达式错误！");
            }
            else
            {
                System.out.println("表达式正确！");
            }
            if(n == a + 1)
                buf.close();//关闭流对象
        }
        
        public static void main(String[] args) throws IOException {
            
            int n;
            ex3 Re = new ex3();
                n = 1;
            for(int a = 0;a < n;a++)
            {
                Re.mainoperation(n,a);//主控程序
            }
        }
     
    }