打破国外垄断，开发中国人自己的编程语言（1）：实现可以解析表达式的计算器

expr: expr op=('*'|'/') expr | expr op=('+'|'-') expr

grammar Hello;
r  : 'hello' ID ;
ID : [a-z]+ ;
WS : [ trn]+ -> skip ; 

if(i == 10)
{ }

if,(,i,==,10,),{,}

hello world
hello abc
hello Bill
hello 李宁

r : 'hello' ID;

ID : [a-z]+ ;

hello
world

grammar Ori;
program : sourceElements? EOF
sourceElement   : statement
statement
:
    importStatement
    | sqlStatement
    | dollarMemberStatement        
    |  classDeclarationStatement
    |  interfaceDeclarationStatement
    | functionDeclarationStatement
    | variableStatement     
    | ifStatement                
    | iterationStatement         
    | continueStatement           
    | breakStatement       
    | returnStatement             
    | withStatement             
    | switchStatement           
    | throwStatement           
    | tryStatement                 
    | blockStatement  
    | expressionStatement
    | commentStatement
    ;  

import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;

public class MyHelloVisitor extends AbstractParseTreeVisitor<String> implements HelloVisitor<String> {

    @Override public String visitR(HelloParser.RContext ctx) {
        System.out.println(ctx.getText());
        System.out.println(ctx.ID().getText());
        return visitChildren(ctx);
    }
}

import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.tree.ParseTree;

public class Hello {
    public static void main(String[] args) throws Exception  {
         // 读取源代码文件，这里选择直接从字符串读取
         CharStream input = CharStreams.fromString("hello world");
        // 创建词法分析器对象 
        HelloLexer lexer = new HelloLexer(input);
        // 获取词法分析器输出的tokens
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        // 创建语法分析器对象，并将词法分析器输出的tokens作为语法分析器的输入
        HelloParser parser = new HelloParser(tokens);
        // 开始分析程序，这也是生成AST的过程
        ParseTree tree = parser.r();    // 文法的入口点r会转换为一个方法，调用该方法，就会自顶向下递归分析源代码
        // 创建Visitor对象
        MyHelloVisitor hello = new MyHelloVisitor();
        // 开始遍历AST
        hello.visit(tree);
    }
}

import org.antlr.v4.runtime.tree.ParseTreeVisitor;
public interface HelloVisitor<T> extends ParseTreeVisitor<T> {    
    T visitR(HelloParser.RContext ctx);
}

import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;

public class HelloBaseVisitor<T> extends AbstractParseTreeVisitor<T> implements HelloVisitor<T> {
    
    @Override public T visitR(HelloParser.RContext ctx) { return visitChildren(ctx); }
}

grammar Calc;
// 下面是语法
prog:   stat+ ;

stat:   expr ';'                # printExpr
    |   ID '=' expr ';'         # assign
    |   NEWLINE                 # blank
    ;

expr:   expr op=('*'|'/') expr      # MulDiv
    |   expr op=('+'|'-') expr      # AddSub
    |   INT                         # int
    |   ID                          # id
    |   '(' expr ')'                # parens
    ;
// 下面是词法
MUL :   '*' ;
DIV :   '/' ;
ADD :   '+' ;
SUB :   '-' ;
ID  :   [a-zA-Z]+ ;      // 匹配标识符
INT :   [0-9]+ ;         // 匹配整数
WS  :   [ t]+ -> skip ; // 忽略空白符
NEWLINE:'r'? 'n' ;     // 空行

import org.antlr.v4.runtime.tree.ParseTreeVisitor;
public interface CalcVisitor<T> extends ParseTreeVisitor<T> {
    T visitProg(CalcParser.ProgContext ctx);    
    T visitPrintExpr(CalcParser.PrintExprContext ctx);
    T visitAssign(CalcParser.AssignContext ctx);
    T visitBlank(CalcParser.BlankContext ctx);
    T visitParens(CalcParser.ParensContext ctx);
    T visitMulDiv(CalcParser.MulDivContext ctx);
    T visitAddSub(CalcParser.AddSubContext ctx);
    T visitId(CalcParser.IdContext ctx);
    T visitInt(CalcParser.IntContext ctx);
}

import java.util.HashMap;
import java.util.Map;

public class EvalVisitor extends CalcBaseVisitor<Integer> {
    /** "memory" for our calculator; variable/value pairs go here */
    Map<String, Integer> memory = new HashMap<String, Integer>();
    boolean error = false;

    /** ID '=' expr NEWLINE */
    // 初始化变量的操作（赋值操作）
    @Override
    public Integer visitAssign(CalcParser.AssignContext ctx) {
        String id = ctx.ID().getText();  // id is left-hand side of '='
        int value = visit(ctx.expr());   // compute value of expression on right
        memory.put(id, value);           // store it in our memory
        return value;
    }

    /** expr NEWLINE */
    // 输出表达式的计算结果
    @Override
    public Integer visitPrintExpr(CalcParser.PrintExprContext ctx) {
        Integer value = visit(ctx.expr()); // evaluate the expr child
        System.out.println(value);         // print the result
        return 0;                          // return dummy value
    }

    /** INT */
    // 将字符串形式的整数转换为整数类型
    @Override
    public Integer visitInt(CalcParser.IntContext ctx) {
        return Integer.valueOf(ctx.INT().getText());
    }

    /** ID */
    @Override
    public Integer visitId(CalcParser.IdContext ctx) {
        String id = ctx.ID().getText();
        // 从Map中获取变量的值 
        if ( memory.containsKey(id) ) {
            return memory.get(id);
        } else {
            // 引用了不存在的变量，输出错误信息 
            System.err.println(String.format("变量<%s> 不存在！",id));
            error = true;

        }
        return 0;
    }

    /** expr op=('*'|'/') expr */
    // 计算乘法和除法
    @Override
    public Integer visitMulDiv(CalcParser.MulDivContext ctx) {

        int left = visit(ctx.expr(0));  // get value of left subexpression
        int right = visit(ctx.expr(1)); // get value of right subexpression

        if ( ctx.op.getType() == CalcParser.MUL ) return left * right;
        return left / right; // must be DIV
    }

    // 计算加法和减法
    /** expr op=('+'|'-') expr */
    @Override
    public Integer visitAddSub(CalcParser.AddSubContext ctx) {
        int left = visit(ctx.expr(0));  // get value of left subexpression
        int right = visit(ctx.expr(1)); // get value of right subexpression
        if ( ctx.op.getType() == CalcParser.ADD ) return left + right;
        return left - right; // must be SUB
    }

    /** '(' expr ')' */
    // 处理括号表达式
    @Override
    public Integer visitParens(CalcParser.ParensContext ctx) {
        return visit(ctx.expr()); // return child expr's value
    }
}

import org.antlr.v4.runtime.ANTLRInputStream;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.tree.ParseTree;
import java.io.FileInputStream;
import java.io.InputStream;

public class MarvelCalc {
    public static void main(String[] args) throws Exception  {
        // 从文件读取源代码 
        String inputFile = null;
        if ( args.length>0 ) {
            inputFile = args[0];
        } else {
            System.out.println("语法格式：MarvelCalc inputfile");
            return;
        }
        InputStream is = System.in;
        if ( inputFile!=null ) is = new FileInputStream(inputFile);


        CharStream input = CharStreams.fromStream(is);

        CalcLexer lexer = new CalcLexer(input);
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        CalcParser parser = new CalcParser(tokens);
        ParseTree tree = parser.prog(); // 分析源代码

        EvalVisitor eval = new EvalVisitor();


        eval.visit(tree);
    }
}

1+3 * 4 - 12 /6;
x = 40;
y = 13;
x * y + 20 - 42/6;
z = 12;
x + 5 * z - y;

11
533
87