实验3《递归下降分析法设计与实现》（java版）

第1关：递归分析法设计与实现

100

• 任务要求
• 参考答案
• 评论

• 任务描述
• 相关知识
  • 递归分析法
  • 实验步骤
• 编程要求
• 测试说明

---

任务描述

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

相关知识

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

递归分析法

递归下降分析法，顾名思义就是使用递归的思想去分析。对于一个文法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);
            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);
            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);
            outputspace(p+1,m);
            return flag;
        }
        else if(ch.equals("("))
        {
            p=p+1;
            ch=buffer.substring(p,p+1);
            outputspace(p+1,m);
            plusandminus();
            if(ch.equals(")"))
            {
                p=p+1;
                ch=buffer.substring(p,p+1);
                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);//主控程序
        }
    }
 
}