解释器模式

rot is 0;
origin is (0, 0);
scale is (2,20);
for T from 1 to 300 step 1 draw (t,-ln(t));
scale is (20,0.1);
for T from 0 to 8 step 0.1 draw (t,exp(t));
scale is (2,1);
for T from 0 to 300 step 1 draw (t,0);
for T from 0 to 300 step 1 draw (0,t);
for T from 0 to 120 step 1 draw (t,t);
scale is (2,0.1);
for T from 0 to 55 step 1 draw (t,-(t*t));
scale is (10,5);
for T from 0 to 60 step 1 draw (t,sqrt(t));

<句子> -> <主语><谓语><表语> 
<主语> -> <代词> | <名词>
<谓语> -> <动词> 
<表语> -> <名词> | <形容词>
 <名词> -> rot|origin|scale
 <动词> -> is
 <形容词> -> 0|(0,0)|(2,20)
注：这里的符号"->"表示“定义为”的意思，用"<"和">"括住的是非终结符，没有括住的是终结符。

// 语法
public interface Grammar {
   void interpret(Parser parser);
}

// 终结符类型
public enum TokenType {
    ROT, IS, ORIGIN, SCALE, FOR, FROM, TO, STEP, DRAW, // 保留字
    T, // 参数
    SEMICOLON, COMMA, LEFT_BRACKET, RIGHT_BRACKET, // 分隔符
    EOF, // 文件结束符
    PLUS, MINUS, MUL, DIV, // 运算符
    LN, EXP, SQRT, SIN, COS, POWER, // 函数
    NUMBER // 数字
}
// 具体终结符
public class Token implements Grammar {
    public static final Map<String, Token> TOKEN_MAP;

    static {
        Map<String, Token> tokenMap = new HashMap<>();
        tokenMap.put("ROT", new Token(TokenType.ROT, "ROT"));
        tokenMap.put("IS", new Token(TokenType.IS, "IS"));
        tokenMap.put("ORIGIN", new Token(TokenType.ORIGIN, "ORIGIN"));
        tokenMap.put("SCALE", new Token(TokenType.SCALE, "SCALE"));
        tokenMap.put("FOR", new Token(TokenType.FOR, "FOR"));
        tokenMap.put("FROM", new Token(TokenType.FROM, "FROM"));
        tokenMap.put("TO", new Token(TokenType.TO, "TO"));
        tokenMap.put("STEP", new Token(TokenType.STEP, "STEP"));
        tokenMap.put("DRAW", new Token(TokenType.DRAW, "DRAW"));
        tokenMap.put(";", new Token(TokenType.SEMICOLON, ";"));
        tokenMap.put("(", new Token(TokenType.LEFT_BRACKET, "("));
        tokenMap.put(")", new Token(TokenType.RIGHT_BRACKET, ")"));
        tokenMap.put(",", new Token(TokenType.COMMA, ","));
        tokenMap.put("NUMBER", new Token(TokenType.NUMBER, null));
        tokenMap.put("EOF", new Token(TokenType.EOF, null));
        tokenMap.put("T", new Token(TokenType.T, "T"));
        tokenMap.put("+", new Token(TokenType.PLUS, "+"));
        tokenMap.put("-", new Token(TokenType.MINUS, "-"));
        tokenMap.put("*", new Token(TokenType.MUL, "*"));
        tokenMap.put("/", new Token(TokenType.DIV, "/"));
        tokenMap.put("LN", new Token(TokenType.LN, null));
        tokenMap.put("EXP", new Token(TokenType.EXP, null));
        tokenMap.put("SQRT", new Token(TokenType.SQRT, null));
        tokenMap.put("SIN", new Token(TokenType.SIN, null));
        tokenMap.put("COS", new Token(TokenType.COS, null));
        tokenMap.put("^", new Token(TokenType.POWER, null));
        TOKEN_MAP = tokenMap;
    }

    private TokenType type;
    private Object value;

    public Token(TokenType type, Object value) {
        this.type = type;
        this.value = value;
    }

    public TokenType getType() {
        return type;
    }

    public Object getValue() {
        return value;
    }

    public Token setValue(Object value) {
        this.value = value;
        return this;
    }

    @Override
    public void interpret(Parser parser) {
        // do nothing
    }
}

// 非终结符
// 旋转语句
public class RotateStatement implements Grammar {
   @Override
   public void interpret(Parser parser) {
      /**
       * 解释ROT IS NUMBER，即旋转角度，将角度存入上下文中，供后续语句使用。
       * 语法分析：先识别ROT，然后再识别IS，最后识别NUMBER。
       **/
      parser.matchToken(TokenType.ROT);
      parser.matchToken(TokenType.IS);
      parser.setRot((Double) parser.getCurrentToken().getValue());
      parser.matchToken(TokenType.NUMBER);
      parser.matchToken(TokenType.SEMICOLON);
   }
}

// 解释器
public class Parser {
    // 语法规则
    private Lexer lexer;
    // 当前token
    private Token currentToken;
    // 输出
    private String output;
    // 旋转角度
    private double rot;
    // 原点坐标
    private double originX;
    private double originY;
    // 缩放比例
    private double scaleX;
    private double scaleY;
    private double from;
    private double to;
    private double step;
    private ExprNode xNode;
    private ExprNode yNode;
    // 语句解释映射
    private Map<TokenType, Grammar> statementMap;
    public Parser(Lexer lexer) {
        this.lexer = lexer;
        this.output = "";
        this.rot = 0;
        this.originX = 0;
        this.originY = 0;
        this.scaleX = 1;
        this.scaleY = 1;
        statementMap = new HashMap<>();
        statementMap.put(TokenType.ROT, new RotateStatement());
        statementMap.put(TokenType.ORIGIN, new OriginStatement());
        statementMap.put(TokenType.SCALE, new ScaleStatement());
        statementMap.put(TokenType.FOR, new ForStatement());
    }
}
// 

public class Client {
   public static void main(String[] args) throws IOException {
      Semantic semantic = new Semantic();
      semantic.analyze();
   }
}