130242014029-黄超强-第2次实验

Posted 2020-10-12 黄cq

130242014029-黄超强-第2次实验

 

一、实验目的

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

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

3、理解解释器的原理

4、理解编译器模型

二、实验环境

硬件： 

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

三、实验内容

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

结果要求：

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

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

3）处理空格

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

  图1    实验结果示例

加强练习：

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

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

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

                        图2  管道-过滤器风格

                     图 3  编译器模型示意图

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

四、实验步骤：

     要求写具体实现代码，并根据实际程序，画出程序的总体体系结构图和算法结构图。

package test;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Stack;

public class Calculate {

    public static void main(String[] args) {
        
        while(true){
            System.out.print("calc>");
            //输入表达式
            Scanner in = new Scanner(System.in);
            String expression = in.nextLine();
            //计算表达式
            try {
                 Double t = calculate(expression);
                 System.out.println(t);
            } catch (Exception e) {
                System.out.println("您输入的表达式有误!");
            }
           
        }
    }

    //计算表达式 
    public static double calculate(String expression) {
        //转换表达式为字符数组
        String[] arr = convert(expression);
        //操作数栈
        Stack<Double> val = new Stack<>();
        //操作符栈
        Stack<String> op = new Stack<>();
        //遍历表达式数组
        for (int i = 0; i < arr.length; i++) {
            if (arr[i].equals("(")) {
                val.push(calculate(bracketGet(expression, i)));
                i = i + bracketGet(expression, i).length() + 1;
            } else if (arr[i].equals("+") || arr[i].equals("-") || arr[i].equals("*") || arr[i].equals("/")) {
                        while (!op.isEmpty() && opcompare(op.lastElement(), arr[i])) {
                            switch (op.pop()) {
                            case "+":
                                val.push(val.pop() + val.pop());
                                continue;
                            case "-":
                                double c = val.pop();
                                double d = val.pop();
                                val.push(d - c);
                                continue;
                            case "*":
                                val.push(val.pop() * val.pop());
                                continue;
                            case "/":
                                double a = val.pop();
                                double b = val.pop();
                                val.push(b / a);
                                continue;
                            default:
                                break;
                            }
                        }
                        op.push(arr[i]);        
                } 
                else
                    val.push(Double.parseDouble(arr[i]));

        }
        while (!op.isEmpty()) {
            switch (op.pop()) {
            case "+":
                val.push(val.pop() + val.pop());
                break;
            case "-":
                double c = val.pop();
                double d = val.pop();
                val.push(d - c);
                break;
            case "*":
                val.push(val.pop() * val.pop());
                break;
            case "/":
                double a = val.pop();
                double b = val.pop();
                val.push(b / a);
                break;
            default:
                break;
            }
        }

        return val.pop();
    }
//括号内表达式处理函数
public static String bracketGet(String s, int k) {
        int m=0;
        int i;
        String[] arr=convert(s);
        for(i=k;i<arr.length;i++){
            if(arr[i].equals("(")){
                m++;
                continue;
                }
            if(arr[i].equals(")")){
                m--;
                if(m==0)
                    break;
                else
                    continue;
            }

        }
        StringBuilder sb=new StringBuilder();
        for(int j=k+1;j<i;j++){
            sb.append(arr[j]);
        }
        return sb.toString();
    }
//转换函数
public static String[] convert(String s) {
        ArrayList<String> arrayList = new ArrayList<>();
        for (int i = 0; i < s.length(); i++) {
            if (!opjudge(s.charAt(i))) {
                int j = i;
                while ((i < s.length()) && !opjudge(s.charAt(i)))
                    i++;
                arrayList.add(s.substring(j, i));
                i--;
            } else
                arrayList.add(String.valueOf(s.charAt(i)));
        }

        return arrayList.toArray(new String[arrayList.size()]);

    }
    //操作判断
    public static boolean opjudge(char c) {
    if (c == \'+\' || c == \'-\' || c == \'*\' || c == \'/\' || c == \'(\' || c == \')\')
        return true;
    else
        return false;
}
    //操作符赋值
    public static int opvalue(String s) {
        switch (s) {
        case "+":
            return 1;
        case "-":
            return 2;
        case "*":
            return 3;
        case "/":
            return 4;
        default:
            return -1;
        }

    }
    //操作优先级符比较
    public static boolean opcompare(String s1, String s2) {
        if (opvalue(s1) >= opvalue(s2))
            return true;
        else {
            return false;
        }

    }
}

 对应结果图：