設計模式：解釋器（Interpreter）模式

設計模式：解釋器（Interpreter）模式

一、前言

    這是我們23個設計模式中最后一個設計模式了，大家或許也沒想到吧，竟然是編譯原理上的編譯器，這樣說可能不對，因為編譯器分為幾個部分組成呢，比如詞法分析器、語法分析器、語義分析器、中間代碼優化器以及最終的最終代碼生成器。而這個解釋器其實就是完成了對語法的解析，將一個個的詞組解釋成了一個個語法范疇，之后拿來使用而已。

   為什么會有這個解釋器模式呢，我想這是從編譯原理中受到啟發的，使用了這樣的一個解釋器可以在Java語言之上在定義一層語言，這種語言通過Java編寫的解釋器可以放到Java環境中去執行，這樣如果用戶的需求發生變化，比如打算做其他事情的時候，只用在自己定義的新的語言上進行修改，對於Java編寫的代碼不需要進行任何的修改就能在Java環境中運行，這是非常有用的。這就好像，雖然不管怎么編譯，最終由中間代碼生成最終代碼（機器碼）是依賴於相應的機器的。但是編譯器卻能理解高級語言和低級語言，無論高級語言的程序是怎么樣編寫的，編譯器的代碼是不用修改的，而解釋器模式就是想做一個建立在Java和我們自定義語言之間的編譯器。

 

二、代碼

   本程序使用自頂向下文法來解析源程序：

   首先是文法的定義：

1 <program> -> program <Command List> 2 3 <Command List> -> <Command>* end 4 5 <Command> -> <Repeat Command> | <Primitive Command> 6 7 <Repeat Command> -> repeat <number> <Command List> 8 9 <Primitive Command> -> go | right | left

    由此可以生成一顆語法樹。

    然后使用自頂向下文法生成這樣的語法樹，自頂向下文法從根節點開始，不斷的向下解析，遇到一個語法范疇就嘗試着自己的定義去解析，直至解析到相應的程序，這里要注意二義性問題，不能嘗試兩種解析方式都能對源程序解析成功；在實現的時候將一個語法范疇定義為一個類，然后不斷地遞歸的去解析，直至到了葉子節點，將所有的單詞解析完畢。

 Node抽象類：

package zyr.dp.interpreter;

public abstract class Node {
    public abstract void parse(Context context) throws ParseException;
}

 ProgramNode：起始節點  <program> -> program <Command List>

package zyr.dp.interpreter;

public class ProgramNode extends Node {

    private Node commandListNode;
    public void parse(Context context) throws ParseException {
        context.skipToken("program");
        commandListNode=new CommandListNode();
        commandListNode.parse(context);
    }
    public String toString(){
        return "[program "+commandListNode+"]";
    }

}

  CommandListNode類： <Command List> -> <Command>* end

package zyr.dp.interpreter;

import java.util.ArrayList;

public class CommandListNode extends Node {

    private ArrayList list=new ArrayList();
    
    public void parse(Context context) throws ParseException {
        while(true){
            if(context.getCurrentToken()==null){
                throw new ParseException("錯誤！！！"+"當前字符為空");
            }else if(context.getCurrentToken().equals("end")){
                context.skipToken("end");
                break;
            }else{
                Node commandNode=new CommandNode();
                commandNode.parse(context);
                list.add(commandNode);
            }
        }
    }
    
    public String toString(){
        return list.toString();
    }

}

 CommandNode類： <Command> -> <Repeat Command> | <Primitive Command>

package zyr.dp.interpreter;

public class CommandNode extends Node {

    private Node node;
    public void parse(Context context) throws ParseException {
        if(context.getCurrentToken().equals("repeat")){
            node = new RepeatCommandNode();
            node.parse(context);
        }else{
            node = new PrimitiveCommandNode();
            node.parse(context);
        }
    }
    
    public String toString(){
        return node.toString();
    }

}

RepeatCommandNode 類：<Repeat Command> -> repeat <number> <Command List>

package zyr.dp.interpreter;

public class RepeatCommandNode extends Node {

    private int number;
    private Node commandListNode;
    public void parse(Context context) throws ParseException {
        context.skipToken("repeat");
        number=context.currentNumber();
        context.nextToken();
        commandListNode=new CommandListNode();
        commandListNode.parse(context);
    }
    public String toString(){
        return "[repeat "+number+"  "+commandListNode+"]";
    }

}

 PrimitiveCommandNode類：<Primitive Command> -> go | right | left

package zyr.dp.interpreter;

public class PrimitiveCommandNode extends Node {

    String name;
    public void parse(Context context) throws ParseException {
        name=context.getCurrentToken();
        context.skipToken(name);
        if(!name.equals("go") && !name.equals("left") && !name.equals("right") ){
            throw new ParseException("錯誤！！！非法字符："+name);
        }
    }

    public String toString(){
        return name;
    }
}

 ParseException類：

package zyr.dp.interpreter;

public class ParseException extends Exception {

    private static final long serialVersionUID = 3996163326179443976L;

    public ParseException(String word){
        super(word);
    }

}

Context 類，承載了詞法分析的職責，為上面的語法樹提供單詞，遍歷程序，當然沒考慮到程序的注釋等處理信息。

package zyr.dp.interpreter;

import java.util.StringTokenizer;

public class Context {

    private StringTokenizer tokenizer ;
    private String currentToken;
    public Context(String token){
        tokenizer=new StringTokenizer(token);
        nextToken();
    }
    public String nextToken() {
        if(tokenizer.hasMoreTokens()){
            currentToken=tokenizer.nextToken();
        }else{
            currentToken=null;
        }
        return currentToken;
    }
    public String getCurrentToken(){
        return currentToken;
    }
    public void skipToken(String token) throws ParseException{
        if(!token.equals(currentToken)){
            throw new ParseException("錯誤！！！"+"期待"+currentToken+"但是卻得到"+token);
        }
        nextToken();
    }
    public int currentNumber() throws ParseException{
        int num=0;
        try{
            num=Integer.parseInt(currentToken);
        }catch(NumberFormatException e){
            throw new ParseException(e.toString());
        }
        return num;
    }
    
}

    Main類，讀取用戶編寫的程序並且執行詞法分析和語法分析。這里的詞法分析就是簡單的遍歷程序，語法分析采用的自頂向下的語法分析，對於上下文無關文法可以檢測到語法錯誤，並且能生成語法范疇，但是這些語法范疇是我們能看到的，不是及其最終可以拿來去處理的，真正要編寫編譯系統，最好使用，自下而上的算符優先文法等方式來分析。

package zyr.dp.text;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

import zyr.dp.interpreter.*;

public class Main {

    public static void main(String[] args) {
        
        try {
            BufferedReader  reader = new BufferedReader(new FileReader("program.txt"));
            String line=null;
            while((line=reader.readLine())!=null){
                System.out.println("源程序為："+line);
                System.out.println("自頂向下解析為：");
                Node node=new ProgramNode();
                node.parse(new Context(line));
                System.out.println(node);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        
    }

}

 運行結果：

  源程序：

  在這里我專門寫錯了一個源程序：

program end
program go end
program go right  go right  go right  go right  go right  go right  end
program repeat 4 go right end end
program repeat 4 repeat 3  go right end go right end end
6 program repeat 4 go right end

    可以看到編譯器檢測到了語法錯誤，對於語法正確的，也形式化的生成了自己的分析結果，使用[ ]括起來的就是語法范疇了，形成層次遞歸嵌套結構。

三、總結

    最后的設計模式是解釋器模式，在Java這種高級語言之上再次定義一種語言的編譯器，然后在不改動這個編譯器的條件下，也就是不改變Java代碼就能夠隨意的書寫更高級的代碼，然后執行。在這種模式之下java程序都不用修改，只用修改上面的文本文件就可以了，非常的方便，適合於結構已經固定，但是可以隨意修改功能的場合。

  程序代碼