一、實驗目的

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 編譯器模型示意圖

本實驗，實現的是詞法分析和語法分析兩個部分。

四、實驗步驟：

要求寫具體實現代碼，並根據實際程序，畫出程序的總體體系結構圖和算法結構圖。

總體結構圖參照體系結構風格。

算法結構圖參照如下：

源代碼：

import java.util.*;

/**
 * Created by hasee on 2017/10/28.
 
 
*/
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while(true){
            System.out.print("calc > ");
            String text = scanner.nextLine();
            if (interpreter(text))
                System.out.println(calculate(lexer(text)));
            
 
else
                System.out.println("輸入有誤，請重新輸入！！");
        }

    }

    /*
    去除空字符串並將插入到隊列中
     */
    public static List<Object> lexer(String s) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("+", 0);
        map.put("-", 0);
        map.put("*", 1);
        map.put("/", 1);
        List<Object> list = new ArrayList<Object>();
        s = s.replace(" ", "");
        String[] number = s.split("[^\\d]");
        String[] operator = s.split("\\d+");
        Stack<String> stack = new Stack<String>();
        for (int i = 0; i < number.length; i++) {
            if (operator[i].length() != 0) {
                while (!stack.isEmpty()
                        && map.get(operator[i]) <= map.get(stack.peek())) {
                    list.add(stack.pop());
                }
                stack.push(operator[i]);
            }
            list.add(Double.parseDouble(number[i]));
        }
        while (!stack.isEmpty()) {
            list.add(stack.pop());
        }
        return list;
    }

    /**
     * 計算
     * @param list
     * @return
     */
    public static double calculate(List<Object> list) {
        Stack<Double> stack = new Stack<Double>();
        for (Object obj : list) {
            if (obj instanceof Double) {
                stack.push((Double) obj);
            } else {
                double b = stack.pop();
                double a = stack.pop();
                if (obj.equals("-"))
                    stack.push(a - b);
                if (obj.equals("*"))
                    stack.push(a * b);
                if (obj.equals("/"))
                    stack.push(a / b);
                if (obj.equals("+"))
                    stack.push(a + b);

            }
        }
        return stack.pop();
    }

    /**
     * 語法分析
     * @param text
     * @return
     */
    private static boolean interpreter(String text) {

        String[] signs = {"+", "-", "*", "/"};
        boolean isRight = true;

        boolean haveSign = false;
        for (String sign : signs) {

            if (text.contains(sign)) {
                haveSign = true;
            }

            if (text.contains(sign + sign)) {
                isRight = false;
            }

            if ( text.indexOf(sign) == 0 || text.lastIndexOf(sign) == text.length() - 1) {
                isRight = false;
            }
        }
        isRight = isRight && haveSign;
        return isRight;
    }
}

130242014056 王鈺鵬 第2次實驗