130242014075+杨利城+第2次实验

一、实验目的

1．熟悉体系结构的风格的概念

2．理解和应用管道过滤器型的风格。

3、理解解释器的原理

4、理解编译器模型

二、实验环境

硬件： 

软件：Python或任何一种自己喜欢的语言

三、实验内容

1、实现“四则运算”的简易翻译器。

结果要求：

1）实现加减乘除四则运算，允许同时又多个操作数，如：2+3*5-6 结果是11

2）被操作数为整数，整数可以有多位

3）处理空格

4）输入错误显示错误提示，并返回命令状态“CALC”

加强练习：

1、有能力的同学，可以尝试实现赋值语句，例如x=2+3*5-6，返回x=11。（注意：要实现解释器的功能，而不是只是显示）

2、尝试实现自增和自减符号，例如x++ 

2、采用管道-过滤器（Pipes and Filters）风格实现解释器

本实验，实现的是词法分析和语法分析两个部分。

四、实验步骤：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestCalculator {
     
    public static void main(String[] args){
         
        BufferedReader reader=null;
        InputStreamReader inputStreamReader=null;
        try{
        	System.out.print("calc>");
        	//用输入流读取输入的数据
            inputStreamReader=new InputStreamReader(System.in);
            reader=new BufferedReader(inputStreamReader);
            String str=reader.readLine();
            //判断是否退出
            while(!str.equals("#")){
                System.out.println(opt(str));
                System.out.print("calc>");
                str=reader.readLine();
            }
        }catch(Exception e){
        	System.out.println("输入错误，请检查");
        }
        //判断输入不能为空
        if(reader!=null){
            try {
                reader.close();
            } catch (IOException e) {
            	System.out.println("输入错误，请检查");
            }
        }
    }
    
    //加减乘数运算
    public static Integer opt(String s) throws Exception{
        if(s == null || "".equals(s.trim())) {
            return 0;
        }
        int add=s.indexOf("+");
        int minus=s.indexOf("-");
        int multiply=s.indexOf("*");
        int division=s.indexOf("/");
        int bracketsLeft=s.indexOf("(");
        if(add==-1&&minus==-1&&multiply==-1&&division==-1){
            if(s.trim()==null||"".equals(s.trim())){
                throw new Exception("operate error");
            }
            return Integer.parseInt(s.trim());
        }
         
        if(bracketsLeft!=-1){
        int bracketsRight=s.indexOf(")");
            if(bracketsRight==-1){
                throw new Exception("括号不匹配");
            }else{
                float f=opt(s.substring(bracketsLeft+1,bracketsRight).trim());
                s=s.replace(s.substring(bracketsLeft,bracketsRight+1), String.valueOf(f));
                return opt(s);
            }
        }
         
        if(add!=-1){
            return opt(s.substring(0,add))+opt(s.substring(add+1,s.length()));
        }
        if(minus!=-1){
            return opt(s.substring(0,minus))-opt(s.substring(minus+1,s.length()));
        }
        if(multiply!=-1){
            return opt(s.substring(0,multiply))*opt(s.substring(multiply+1,s.length()));
        }
        if(division!=-1){
            return opt(s.substring(0,division))/opt(s.substring(division+1,s.length()));
        }
        return Integer.parseInt(s.trim());
    }
}

结果图

算法结构图

 总体结构图

五、实验总结

解释器和编译器的侧重点不同，编译器注重底层，要求效率；解释器则注重突出各种语言特性。