自定義語言的實現——解釋器模式(五) – JAVA編程語言程序開發技術文章

18.5 再談Context的作用
       在解釋器模式中,環境類Context用於存儲解釋器之外的一些全局信息,它通常作為參數被傳遞到所有表達式的解釋方法interpret()中,可以在Context對象中存儲和訪問表達式解釋器的狀態,向表達式解釋器提供一些全局的、公共的數據,此外還可以在Context中增加一些所有表達式解釋器都共有的功能,減輕解釋器的職責。
       在上面的機器人控制程序實例中,我們省略瞭環境類角色,下面再通過一個簡單實例來說明環境類的用途:
       Sunny軟件公司開發瞭一套簡單的基於字符界面的格式化指令,可以根據輸入的指令在字符界面中輸出一些格式化內容,例如輸入“LOOP 2 PRINT楊過 SPACE SPACE PRINT 小龍女 BREAK END PRINT郭靖 SPACE SPACE PRINT 黃蓉”,將輸出如下結果:
楊過     小龍女
楊過     小龍女
郭靖     黃蓉
       其中關鍵詞LOOP表示“循環”,後面的數字表示循環次數;PRINT表示“打印”,後面的字符串表示打印的內容;SPACE表示“空格”;BREAK表示“換行”;END表示“循環結束”。每一個關鍵詞對應一條命令,計算機程序將根據關鍵詞執行相應的處理操作。
       現使用解釋器模式設計並實現該格式化指令的解釋,對指令進行分析並調用相應的操作執行指令中每一條命令。
       Sunny軟件公司開發人員通過分析,根據該格式化指令中句子的組成,定義瞭如下文法規則:
expression ::= command* //表達式,一個表達式包含多條命令
command ::= loop | primitive //語句命令
loop ::= 'loopnumber' expression  'end' //循環命令,其中number為自然數
primitive ::= 'printstring'  | 'space' | 'break' //基本命令,其中string為字符串
       根據以上文法規則,通過進一步分析,繪制如圖18-6所示結構圖:

圖18-6    格式化指令結構圖
       在圖18-6中,Context充當環境角色,Node充當抽象表達式角色,ExpressionNode、CommandNode和LoopCommandNode充當非終結符表達式角色,PrimitiveCommandNode充當終結符表達式角色。完整代碼如下所示:
[java]
import java.util.*; 
 
//環境類:用於存儲和操作需要解釋的語句,在本實例中每一個需要解釋的單詞可以稱為一個動作標記(Action Token)或命令 
class Context { 
    private StringTokenizer tokenizer; //StringTokenizer類,用於將字符串分解為更小的字符串標記(Token),默認情況下以空格作為分隔符 
    private String currentToken; //當前字符串標記 
     
    public Context(String text) { 
        tokenizer = new StringTokenizer(text); //通過傳入的指令字符串創建StringTokenizer對象 
        nextToken(); 
    } 
     
    //返回下一個標記 
    public String nextToken() { 
        if (tokenizer.hasMoreTokens()) { 
            currentToken = tokenizer.nextToken(); 
        } 
        else { 
            currentToken = null; 
        } 
        return currentToken; 
    } 
     
    //返回當前的標記 
    public String currentToken() { 
        return currentToken; 
    } 
     
    //跳過一個標記 
    public void skipToken(String token) { 
        if (!token.equals(currentToken)) { 
            System.err.println("錯誤提示:" + currentToken + "解釋錯誤!"); 
            } 
        nextToken(); 
    } 
     
    //如果當前的標記是一個數字,則返回對應的數值 
    public int currentNumber() { 
        int number = 0; 
        try{ 
            number = Integer.parseInt(currentToken); //將字符串轉換為整數 
        } 
        catch(NumberFormatException e) { 
            System.err.println("錯誤提示:" + e); 
        } 
        return number; 
    } 

 
//抽象節點類:抽象表達式 
abstract class Node { 
    public abstract void interpret(Context text); //聲明一個方法用於解釋語句 
    public abstract void execute(); //聲明一個方法用於執行標記對應的命令 

 
//表達式節點類:非終結符表達式 
class ExpressionNode extends Node { 
    private ArrayList<Node> list = new ArrayList<Node>(); //定義一個集合用於存儲多條命令 
     
    public void interpret(Context context) { 
        //循環處理Context中的標記 
        while (true){ 
            //如果已經沒有任何標記,則退出解釋 
            if (context.currentToken() == null) { 
                break; 
            } 
            //如果標記為END,則不解釋END並結束本次解釋過程,可以繼續之後的解釋 
            else if (context.currentToken().equals("END")) { 
                context.skipToken("END"); 
                break; 
            } 
            //如果為其他標記,則解釋標記並將其加入命令集合 
            else { 
                Node commandNode = new CommandNode(); 
                commandNode.interpret(context); 
                list.add(commandNode); 
            } 
        } 
    } 
     
    //循環執行命令集合中的每一條命令 
    public void execute() { 
        Iterator iterator = list.iterator(); 
        while (iterator.hasNext()){ 
            ((Node)iterator.next()).execute(); 
        } 
    } 

 
//語句命令節點類:非終結符表達式 
class CommandNode extends Node { 
    private Node node; 
     
    public void interpret(Context context) { 
        //處理LOOP循環命令 
        if (context.currentToken().equals("LOOP")) { 
            node = new LoopCommandNode(); 
            node.interpret(context); 
        } 
        //處理其他基本命令 
        else { 
            node = new PrimitiveCommandNode(); 
            node.interpret(context); 
        } 
    } 
     
    public void execute() { 
        node.execute(); 
    } 

 
//循環命令節點類:非終結符表達式 
class LoopCommandNode extends Node { 
    private int number; //循環次數 
    private Node commandNode; //循環語句中的表達式 
     
    //解釋循環命令 
    public void interpret(Context context) { 
        context.skipToken("LOOP"); 
        number = context.currentNumber(); 
        context.nextToken(); 
        commandNode = new ExpressionNode(); //循環語句中的表達式 
        commandNode.interpret(context); 
    } 
     
    public void execute() { 
        for (int i=0;i<number;i++) 
            commandNode.execute(); 
    } 

 
//基本命令節點類:終結符表達式 
class PrimitiveCommandNode extends Node { 
    private String name; 
    private String text; 
     
    //解釋基本命令 
    public void interpret(Context context) { 
        name = context.currentToken(); 
        context.skipToken(name); 
        if (!name.equals("PRINT") && !name.equals("BREAK") && !name.equals ("SPACE")){ 
            System.err.println("非法命令!"); 
        } 
        if (name.equals("PRINT")){ 
            text = context.currentToken(); 
            context.nextToken(); 
        } 
    } 
     
    public void execute(){ 
        if (name.equals("PRINT")) 
            System.out.print(text); 
        else if (name.equals("SPACE")) 
            System.out.print(" "); 
        else if (name.equals("BREAK")) 
            System.out.println(); 
    } 

       在本實例代碼中,環境類Context類似一個工具類,它提供瞭用於處理指令的方法,如nextToken()、currentToken()、skipToken()等,同時它存儲瞭需要解釋的指令並記錄瞭每一次解釋的當前標記(Token),而具體的解釋過程交給表達式解釋器類來處理。我們還可以將各種解釋器類包含的公共方法移至環境類中,更好地實現這些方法的重用和擴展。
       針對本實例代碼,我們編寫如下客戶端測試代碼:
[java] 
class Client{ 
    public static void main(String[] args){ 
        String text = "LOOP 2 PRINT 楊過 SPACE SPACE PRINT 小龍女 BREAK END PRINT 郭靖 SPACE SPACE PRINT 黃蓉"; 
        Context context = new Context(text); 
             
        Node node = new ExpressionNode(); 
        node.interpret(context); 
        node.execute(); 
    } 

       編譯並運行程序,輸出結果如下:
楊過     小龍女
楊過     小龍女
郭靖     黃蓉
作者:劉偉

發佈留言

發佈留言必須填寫的電子郵件地址不會公開。