130242014013+黄超+第2次实验

软件体系结构的第二次实验（解释器风格与管道过滤器风格）

1、实验目的

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

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

　　三、理解解释器的原理

　　四、理解编译器模型

2、实验环境

　　硬件： 

　　软件：Python或任何一种本身喜欢的语言

3、实验内容

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

　　结果要求：

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

　　　　2）被操做数为整数，整数能够有多位

　　　　3）处理空格

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

 　　　　

  　　　　图1    实验结果示例

　　增强练习：

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

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

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

 

                        图2  管道-过滤器风格

 

 

                     图 3  编译器模型示意图

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

4、实验步骤：

　代码以下：

package fjnu.test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Arithmetic {
public static void main(String args[]){
//System.out.println(arithmetic("2.2+((3+4)*2-22)/2*3.2"));
//System.out.println(arithmetic("2+333 *5-6"));
/* try {
System.out.println(arithmetic("1+"));
}catch(Error e){
System.out.println("输入的格式有问题请从新输入");
}*/

Scanner input=new Scanner(System.in);

while(true){
String entry = null;
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

while (true) {
try {
System.out.print("calc > ");
entry = reader.readLine();
if(entry==null ||entry.length()==0)
{
System.out.println("没有输入就回车！");
continue;
}
System.out.println(arithmetic(entry));
} catch (Error e) {
System.out.println("输入的格式和形式是有误的有问题，从新输入正确的格式！");
}catch (Exception e) {
System.out.println("输入的格式和形式是有误的有问题，从新输入正确的格式！");
}

}
}
}
public static double arithmetic(String exp){

String result = parseExp(exp).replaceAll("[\\[\\]]", "");
return Double.parseDouble(result);
}
/**
* 解析计算四则运算表达式，例：2+((3+4)*2-22)/2*3
* @param expression
* @return
*/
public static String parseExp(String expression){
//String numberReg="^((?!0)\\d+(\\.\\d+(?<!0))?)|(0\\.\\d+(?<!0))$";
expression=expression.replaceAll("\\s+", "").replaceAll("^\\((.+)\\)$", "$1");
String checkExp="\\d";
String minExp="^((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))$";
//最小表达式计算
if(expression.matches(minExp)){
String result=calculate(expression);

return Double.parseDouble(result)>=0?result:"["+result+"]";
}
//计算不带括号的四则运算
String noParentheses="^[^\\(\\)]+$";
String priorOperatorExp="(((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\])))";
String operatorExp="(((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\])))";
if(expression.matches(noParentheses)){
Pattern patt=Pattern.compile(priorOperatorExp);
Matcher mat=patt.matcher(expression);
if(mat.find()){
String tempMinExp=mat.group();
expression=expression.replaceFirst(priorOperatorExp, parseExp(tempMinExp));
}else{
patt=Pattern.compile(operatorExp);
mat=patt.matcher(expression);

if(mat.find()){
String tempMinExp=mat.group();
expression=expression.replaceFirst(operatorExp, parseExp(tempMinExp));
}
}
return parseExp(expression);
}
//计算带括号的四则运算
String minParentheses="\\([^\\(\\)]+\\)";
Pattern patt=Pattern.compile(minParentheses);
Matcher mat=patt.matcher(expression);
if(mat.find()){
String tempMinExp=mat.group();
expression=expression.replaceFirst(minParentheses, parseExp(tempMinExp));
}
return parseExp(expression);
}
/**
* 计算最小单位四则运算表达式（两个数字）
* @param exp
* @return
*/
public static String calculate(String exp){
exp=exp.replaceAll("[\\[\\]]", "");
String number[]=exp.replaceFirst("(\\d)[\\+\\-\\*\\/]", "$1,").split(",");
BigDecimal number1=new BigDecimal(number[0]);
BigDecimal number2=new BigDecimal(number[1]);
BigDecimal result=null;

String operator=exp.replaceFirst("^.*\\d([\\+\\-\\*\\/]).+$", "$1");
if("+".equals(operator)){
result=number1.add(number2);
}else if("-".equals(operator)){
result=number1.subtract(number2);
}else if("*".equals(operator)){
result=number1.multiply(number2);
}else if("/".equals(operator)){
result=number1.divide(number2);
}
return result!=null?result.toString():null;
}
}