130242014011-林泽祥-第2次实验

Posted 2020-10-12 林泽祥

一、实验目的

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.List;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
* 四则运算，可能不是最优的写法，自己测试没发现bug<br>
* 前提：正确的算式,因为没做算式的验证<br>
* 思路：<br>
* 1、用正则拆分所有的元素例子：2-5+4*5/(2+2)-4<br>
* 拆分为【2,-5,4,*,5,/,(,2,2,),-4】<br>
* 2、先计算括号里，乘除 ，最后加减
*
* 总结：总体花了17、8个小时 ，主要原因还是没有仔细总体分析流程导致。<br>
* 以至于想到点写点代码、修修改改，没有一个完整的把握的思路。所以一个问题一定<br>
* 先走通整个思路、流程 其实编码是最容易的 ，重点是处理的过程思路
*
* @author wangshiyan
* @time 2014-12-4 下午12:50:01
*
*/
public class Calculate {
public static void main(String[] args) {
try {
while(true){
System.out.print("calc>");
Scanner in = new Scanner(System.in);
String e = in.nextLine();

System.out.println(jisuanStr(e));
}

} catch (Exception e) {
System.out.println("请检查你的算式格式");
e.printStackTrace();
}
}

/**
* 拆分算式里的各个元素并处理对应所在位置<br>
*
* @param str
* @return
*/
public static List<String> splitStr(String string) throws Exception {
List<String> listSplit = new ArrayList<String>();
Matcher matcher = Pattern.compile("\\\\-?\\\\d+(\\\\.\\\\d+)?|[*/()]|\\\\-")
.matcher(string);// 用正则拆分成每个元素
while (matcher.find()) {
// System.out.println(matcher.group(0));
listSplit.add(matcher.group(0));
}
return listSplit;
}

/**
* 计算<br>
* 步骤：1、如果有括号<br>
* 然后取上一个最近的(坐标 计算当前括号组合里的算式 ），在继续往下查找括号 以此类推,直至循环使用到所有坐标元素
* 计算完毕（运算顺序括号、乘除、加减）
*
* @param str
* @return
*/
public static double jisuanStr(String str) throws Exception {
double returnDouble = 0;
List<String> listSplit = splitStr(str); // 拆分好的元素
List<Integer> zKuohaoIdxList = new ArrayList<Integer>();// 左括号,<所在坐标，>
if (Pattern.compile(".*\\\\(|\\\\).*").matcher(str).find()) {// 如果包含括号运算
String value = "";// 单个字符值
int zIdx = 0;// 上一个左括号在zKuoHaoIdxList的下标
// 此层循环计算完所有括号里的算式
List<String> tempList = new ArrayList<String>();// 前面没有计算的元素
int removeL = 0;
int tempListSize = 0;
for (int i = 0; i < listSplit.size(); i++) {
value = listSplit.get(i);
tempList.add(value);
tempListSize = tempList.size();
if ("(".equals(value)) {// 左括号
zKuohaoIdxList.add(tempListSize-1);
} else if (")".equals(value)) {// 遇到右括号就计算与上一左括号间的算式
zIdx = zKuohaoIdxList.size() - 1;// 离当前右括号最近的左括号配对
int start = zKuohaoIdxList.get(zIdx);
returnDouble = jisuan(tempList, start + 1, tempListSize-1); // 开始位置,就是上一个左括号
removeL = tempListSize - start;
tempList = removeUseList(tempList, removeL);// 移除已使用的元素
tempList.add(returnDouble + "");// 刚刚计算的值添加进来
zKuohaoIdxList.remove(zIdx);// 计算完毕清除括号
}
}
// 把所有计算完
returnDouble = jisuan(tempList, 0, tempList.size());
} else {// 没有括号运算
returnDouble = jisuan(listSplit, 0, listSplit.size());
}
return returnDouble;
}

/**
* 倒序删除已用过的元素
*
* @param list
* @param removeLength
* 数量
* @return
*/
public static List<String> removeUseList(List<String> list, int removeLength) {
int le = list.size() - removeLength;
for (int i = list.size() - 1; i >= le; i--) {
list.remove(i);
}
return list;
}

/**
* 计算算式
*
* @param listSplit
* @param start
* 括号算式开始符位置
* @param end
* 括号结束符位置
* @return
*/
public static double jisuan(List<String> listSplit, int start, int end)
throws Exception {
double returnValue = 0;
String strValue = null;// 临时变量
List<String> jjValueList = new ArrayList<String>();// 剩下的加减元素
// 遍历计算乘除法
for (int i = start; i < end; i++) {
strValue = listSplit.get(i);
if ("*".equals(strValue) || "/".equals(strValue)) {// 乘除
strValue = jisuanValue("*".equals(strValue) ? "*" : "/", Double
.parseDouble(jjValueList.get(jjValueList.size() - 1)),
Double.parseDouble(listSplit.get(i + 1)))
+ "";
jjValueList.remove(jjValueList.size() - 1);
i++;
}
jjValueList.add(strValue);
}
// 遍历计算加减
for (int j = 0; j < jjValueList.size(); j++) {
strValue = jjValueList.get(j);
if ("-".equals(strValue) || "+".equals(strValue)) {
returnValue = jisuanValue("-".equals(strValue) ? "-" : "+",
returnValue, Double.parseDouble(jjValueList.get(j + 1)));
j++;
} else {
returnValue += Double.parseDouble(jjValueList.get(j));
}
}
return returnValue;
}

/**
* 计算2个数间的加减乘除操作 如：2*5 ，2/5
*
* @param type
* 运算符
* @param start
* 数 相当于上面2
* @param end
* 被数 相当于上面5
* @return
*/
public static double jisuanValue(String type, double start, double end)
throws Exception {
double d = 0;
if ("-".equals(type)) {
d = start - end;
} else if ("+".equals(type)) {
d = start + end;
} else if ("*".equals(type)) {
d = start * end;
} else if ("/".equals(type)) {
if (0 == start || 0 == end)
d = 0;
else
d = start / end;
}
return d;
}

}

 

对应结构图：

 

 

五、实验总结

对于体系结构应用的理解等。