码迷，mamicode.com
首页 > 其他好文 > 详细

130242014074+林泽民+第2次实验

时间：2017-10-27 23:02:36      阅读：181      评论：0      收藏：0      [点我收藏+]

标签：new   赋值语句   符号   epo   词法   repo   ann   pes   sys   

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

一、实验目的

　　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++ 

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

 

 技术分享

 

 

                        图2  管道-过滤器风格

 技术分享

 

 

                       图 3  编译器模型示意图

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

四、实验步骤：

　代码如下：

  1. import java.util.ArrayList;    
  2. import java.util.LinkedList;  
  3. import java.util.Scanner;    
  4.     
  5. /**   
  6.  * @author 林泽民   
  7.  * 实现“四则运算”的简易翻译器。 
  8.  */    
  9. public class Calculator {    
  10.          
  11.      private static boolean rightFormat = true;    
  12.       
  13.      public static double getResult(String formula){      
  14.            
  15.         //处理空格  
  16.          formula=formula.replaceAll(" ", "");  
  17.            
  18.         double returnValue = 0;      
  19.          returnValue = doAnalysis(formula);      
  20.        
  21.          if(!rightFormat){      
  22.             throw new NumberFormatException();  
  23.          }     
  24.          return returnValue;     
  25.      }    
  26.       
  27.      //解析字符串函数  
  28.      private static double doAnalysis(String formula){    
  29.          double returnValue = 0;      
  30.          LinkedList<Integer> stack = new LinkedList<Integer>();      
  31.         int curPos = 0;      
  32.         String beforePart = "";     
  33.         String afterPart = "";      
  34.          String calculator = "";     
  35.          rightFormat = true;    
  36.         //取得括号  
  37.         while(rightFormat&&(formula.indexOf(‘(‘) >= 0||formula.indexOf(‘)‘) >= 0)){             
  38.              curPos = 0;      
  39.             for(char s : formula.toCharArray()){       
  40.                  if(s == ‘(‘){         
  41.                     stack.add(curPos);       
  42.                  }else if(s == ‘)‘){         
  43.                     if(stack.size() > 0){         
  44.                          beforePart = formula.substring(0, stack.getLast());         
  45.                          afterPart = formula.substring(curPos + 1);         
  46.                         calculator = formula.substring(stack.getLast() + 1, curPos);          
  47.                          formula = beforePart + doCalculation(calculator) + afterPart;         
  48.                         stack.clear();         
  49.                         break;         
  50.                      }else{          
  51.                          System.out.println("有未关闭的右括号！");         
  52.                          rightFormat = false;         
  53.                      }       
  54.                 }        
  55.                  curPos++;       
  56.              }       
  57.              if(stack.size() > 0){        
  58.                  System.out.println("有未关闭的左括号！");       
  59.                  break;       
  60.              }     
  61.          }      
  62.         if(rightFormat){      
  63.              returnValue = doCalculation(formula);     
  64.         }      
  65.          return returnValue;     
  66.     }    
  67.          
  68.      //四则运算函数  
  69.      private static double doCalculation(String formula) {      
  70.          ArrayList<Double> values = new ArrayList<Double>();      
  71.          ArrayList<String> operators = new ArrayList<String>();     
  72.          int curPos = 0;     
  73.          int prePos = 0;    
  74.          int minus = 0;          
  75.          for (char s : formula.toCharArray()) {     
  76.               if ((s == ‘+‘ || s == ‘-‘ || s == ‘*‘ || s == ‘/‘) && minus !=0 && minus !=2) {         
  77.                  //将数字分离出来放在double类型里面  
  78.                  values.add(Double.parseDouble(formula.substring(prePos, curPos).trim()));                      
  79.                   operators.add("" + s);                     
  80.                   prePos = curPos + 1;                    
  81.                   minus = minus +1;    
  82.               }else{                  
  83.                   minus =1;                  
  84.               }    
  85.               curPos++;          
  86.         }      
  87.          //去掉前后空格  
  88.          values.add(Double.parseDouble(formula.substring(prePos).trim()));     
  89.          char op;      
  90.          //下面是从容器中取出数字进行运算  
  91.         for (curPos = 0; curPos <= operators.size() - 1; curPos++) {                             
  92.              op = operators.get(curPos).charAt(0);       
  93.             switch (op) {      
  94.              case ‘*‘:        
  95.                  values.add(curPos, values.get(curPos) * values.get(curPos + 1));       
  96.                  values.remove(curPos + 1);        
  97.                  values.remove(curPos + 1);       
  98.                 operators.remove(curPos);      
  99.                  curPos = -1;    
  100.                 break;       
  101.             case ‘/‘:       
  102.                 values.add(curPos, values.get(curPos) / values.get(curPos + 1));        
  103.                 values.remove(curPos + 1);        
  104.                 values.remove(curPos + 1);        
  105.                 operators.remove(curPos);      
  106.                 curPos = -1;    
  107.                 break;       
  108.             }      
  109.         }      
  110.         for (curPos = 0; curPos <= operators.size() - 1; curPos++) {       
  111.             op = operators.get(curPos).charAt(0);      
  112.             switch (op) {      
  113.             case ‘+‘:        
  114.                 values.add(curPos, values.get(curPos) + values.get(curPos + 1));        
  115.                 values.remove(curPos + 1);        
  116.                 values.remove(curPos + 1);       
  117.                 operators.remove(curPos);      
  118.                 curPos = -1;    
  119.                 break;     
  120.             case ‘-‘:        
  121.                 values.add(curPos, values.get(curPos) - values.get(curPos + 1));       
  122.                 values.remove(curPos + 1);     
  123.                 values.remove(curPos + 1);       
  124.                 operators.remove(curPos);      
  125.                 curPos = -1;    
  126.                 break;      
  127.             }     
  128.         }      
  129.         return values.get(0).doubleValue();    
  130.     }    
  131.       
  132.     //主函数  
  133.     public static void main(String[] args) {         
  134.           
  135.         String str;  
  136.         Scanner scan = new Scanner(System.in);  
  137.             
  138.         while (true){  
  139.               
  140.             System.out.print("calc > ");    
  141.             str=scan.nextLine();  
  142.             try{      
  143.                 System.out.println(getResult(str));      
  144.             }catch(NumberFormatException exc){      
  145.                 System.out.println("格式输入有误，请重新输入！");    
  146.             }  
  147.               
  148.         }  
  149.           
  150.     }    
  151.         
  152. }    

 

结果如下：

 技术分享

 

对应结构图：

技术分享

 

 

130242014074+林泽民+第2次实验

标签：new   赋值语句   符号   epo   词法   repo   ann   pes   sys   

原文地址：http://www.cnblogs.com/smirk-xiaoze/p/7745479.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！