一、實驗目的

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 fjnu.test;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.regex.Pattern;

public class Test {
public static void main(String args[]) {

Test test = new Test();
Scanner scanner = new Scanner(System.in);
String str;
while (true) {
System.out.print("calc > ");
str = scanner.nextLine();
try {
System.out.println(test.computeWithVector(str));
}catch (Exception e) {
System.out.println("輸入有誤！");
}
}
}

/**
* 利用java.util.Vector計算四則運算字符串表達式的值，如果拋出異常，則說明表達式有誤，這裏就沒有控制
* @param computeExpr 四則運算字符串表達式
* @return 計算結果
*/
public double computeWithVector(String computeExpr) {
StringTokenizer tokenizer = new StringTokenizer(computeExpr, "+-*/()", true);
Vector<Double> nums = new Vector<Double>();
Vector<Operator> operators = new Vector<Operator>();
Map<String, Operator> computeOper = this.getComputeOper();
Operator curOper;
String currentEle;
while (tokenizer.hasMoreTokens()) {
currentEle = tokenizer.nextToken().trim();
if (!"".equals(currentEle)) {//只處理非空字符
if (this.isNum(currentEle)) { // 數字
nums.add(Double.valueOf(currentEle));
} else { // 非數字，即括號或者操作符
curOper = computeOper.get(currentEle);
if (curOper != null) { // 是運算符
// 運算列表不為空且之前的運算符優先級較高則先計算之前的優先級
while (!operators.isEmpty()
&& operators.lastElement().priority() >= curOper
.priority()) {
compute(nums, operators);
}
// 把當前運算符放在運算符隊列的末端
operators.add(curOper);
} else { // 括號
if ("(".equals(currentEle)) { // 左括號時直接放入操作列表中
operators.add(Operator.BRACKETS);
} else {// 當是右括號的時候就把括號裏面的內容執行了。
// 循環執行括號裏面的內容直到遇到左括號為止。試想這種情況(2+5*2)
while (!operators.lastElement().equals(Operator.BRACKETS)) {
compute(nums, operators);
}
//移除左括號
operators.remove(operators.size()-1);
}
}
}
}
}
// 經過上面代碼的遍歷後最後的應該是nums裏面剩兩個數或三個數，operators裏面剩一個或兩個運算操作符
while (!operators.isEmpty()) {
compute(nums, operators);
}
return nums.firstElement();
}

/**
* 利用java.util.Stack計算四則運算字符串表達式的值，如果拋出異常，則說明表達式有誤，這裏就沒有控制
* java.util.Stack其實也是繼承自java.util.Vector的。
* @param computeExpr 四則運算字符串表達式
* @return 計算結果
*/
public double computeWithStack(String computeExpr) {
//把表達式用運算符、括號分割成一段一段的，並且分割後的結果包含分隔符
StringTokenizer tokenizer = new StringTokenizer(computeExpr, "+-*/()", true);
Stack<Double> numStack = new Stack<Double>(); //用來存放數字的棧
Stack<Operator> operStack = new Stack<Operator>(); //存放操作符的棧
Map<String, Operator> computeOper = this.getComputeOper(); //獲取運算操作符
String currentEle; //當前元素
while (tokenizer.hasMoreTokens()) {
currentEle = tokenizer.nextToken().trim(); //去掉前後的空格
if (!"".equals(currentEle)) { //只處理非空字符
if (this.isNum(currentEle)) { //為數字時則加入到數字棧中
numStack.push(Double.valueOf(currentEle));
} else { //操作符
Operator currentOper = computeOper.get(currentEle);//獲取當前運算操作符
if (currentOper != null) { //不為空時則為運算操作符
while (!operStack.empty() && operStack.peek().priority() >= currentOper.priority()) {
compute(numStack, operStack);
}
//計算完後把當前操作符加入到操作棧中
operStack.push(currentOper);
} else {//括號
if ("(".equals(currentEle)) { //左括號時加入括號操作符到棧頂
operStack.push(Operator.BRACKETS);
} else { //右括號時, 把左括號跟右括號之間剩余的運算符都執行了。
while (!operStack.peek().equals(Operator.BRACKETS)) {
compute(numStack, operStack);
}
operStack.pop();//移除棧頂的左括號
}
}
}
}
}
// 經過上面代碼的遍歷後最後的應該是nums裏面剩兩個數或三個數，operators裏面剩一個或兩個運算操作符
while (!operStack.empty()) {
compute(numStack, operStack);
}
return numStack.pop();
}

/**
* 判斷一個字符串是否是數字類型
* @param str
* @return
*/
private boolean isNum(String str) {
String numRegex = "^\\d+(\\.\\d+)?$"; //數字的正則表達式
return Pattern.matches(numRegex, str);
}

/**
* 獲取運算操作符
* @return
*/
private Map<String, Operator> getComputeOper() {
return new HashMap<String, Operator>() { // 運算符
private static final long serialVersionUID = 7706718608122369958L;
{
put("+", Operator.PLUS);
put("-", Operator.MINUS);
put("*", Operator.MULTIPLY);
put("/", Operator.DIVIDE);
}
};
}

/**
* 取nums的最後兩個數字，operators的最後一個運算符進行運算，然後把運算結果再放到nums列表的末端
* @param nums
* @param operators
*/
private void compute(Vector<Double> nums, Vector<Operator> operators) {
Double num2 = nums.remove(nums.size() - 1); // 第二個數字，當前隊列的最後一個數字
Double num1 = nums.remove(nums.size() - 1); // 第一個數字，當前隊列的最後一個數字
Double computeResult = operators.remove(operators.size() - 1).compute(
num1, num2); // 取最後一個運算符進行計算
nums.add(computeResult); // 把計算結果重新放到隊列的末端
}

/**
* 取numStack的最頂上兩個數字，operStack的最頂上一個運算符進行運算，然後把運算結果再放到numStack的最頂端
* @param numStack 數字棧
* @param operStack 操作棧
*/
private void compute(Stack<Double> numStack, Stack<Operator> operStack) {
Double num2 = numStack.pop(); // 彈出數字棧最頂上的數字作為運算的第二個數字
Double num1 = numStack.pop(); // 彈出數字棧最頂上的數字作為運算的第一個數字
Double computeResult = operStack.pop().compute(
num1, num2); // 彈出操作棧最頂上的運算符進行計算
numStack.push(computeResult); // 把計算結果重新放到隊列的末端
}

/**
* 運算符
*/
private enum Operator {
/**
* 加
*/
PLUS {
@Override
public int priority() {
return 1;
}

@Override
public double compute(double num1, double num2) {
return num1 + num2;
}
},
/**
* 減
*/
MINUS {
@Override
public int priority() {
return 1;
}

@Override
public double compute(double num1, double num2) {
return num1 - num2;
}
},
/**
* 乘
*/
MULTIPLY {
@Override
public int priority() {
return 2;
}

@Override
public double compute(double num1, double num2) {
return num1 * num2;
}
},
/**
* 除
*/
DIVIDE {
@Override
public int priority() {
return 2;
}

@Override
public double compute(double num1, double num2) {
return num1 / num2;
}
},
/**
* 括號
*/
BRACKETS {
@Override
public int priority() {
return 0;
}

@Override
public double compute(double num1, double num2) {
return 0;
}
};
/**
* 對應的優先級
* @return
*/
public abstract int priority();

/**
* 計算兩個數對應的運算結果
* @param num1 第一個運算數
* @param num2 第二個運算數
* @return
*/
public abstract double compute(double num1, double num2);
}
}

130242014006-楊俊傑-第二次實驗