1
2
3
4
5

grammar Hello;              // 语法名称，必须要和文件名称一样

r  : 'hello' ID ;           // 表示匹配字符串hello和ID这个token，语法名称用小写字母定义
ID : [a-z]+ ;               // ID这个token的定义只允许小写字母，词法名称用大写字母定义
WS : [ \t\r\n]+ -> skip ;   // 忽略一些字符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

grammar Calc;       // 语法的名称，要和文件名称一致

calc: (expr)* EOF;  // 一个或多个表达式

expr:
    BRACKET_L expr BRACKET_R                    // 圆括号
    | (ADD | SUB)? (NUMBER | PERCENT_NUMBER)    // 正负数字和百分数
    | expr (MUL | DIV) expr                     // 乘除法
    | expr (ADD | SUB) expr;                    // 加减法

PERCENT_NUMBER: NUMBER PERCENT; // 百分数
NUMBER: DIGIT (POINT DIGIT)?;   // 小数

DIGIT: [0-9]+;  // 数字
BRACKET_L: '('; // 左括号
BRACKET_R: ')'; // 右括号
ADD: '+';
SUB: '-';
MUL: '*';
DIV: '/';
PERCENT: '%';
POINT: '.';

WS: [ \t\r\n]+ -> skip; // 跳过空格换行等字符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

➜ grun Calc calc -tree
1 + 2 * (3 + 4) - 5 / 6       
(calc (expr (expr (expr 1) + (expr (expr 2) * (expr ( (expr (expr 3) + (expr 4)) )))) - (expr (expr 5) / (expr 6))) <EOF>)

➜ grun Calc calc -tokens
1 + 2 * (3 + 4) - 5 / 6       
[@0,0:0='1',<NUMBER>,1:0]
[@1,2:2='+',<'+'>,1:2]
[@2,4:4='2',<NUMBER>,1:4]
[@3,6:6='*',<'*'>,1:6]
[@4,8:8='(',<'('>,1:8]
[@5,9:9='3',<NUMBER>,1:9]
[@6,11:11='+',<'+'>,1:11]
[@7,13:13='4',<NUMBER>,1:13]
[@8,14:14=')',<')'>,1:14]
[@9,16:16='-',<'-'>,1:16]
[@10,18:18='5',<NUMBER>,1:18]
[@11,20:20='/',<'/'>,1:20]
[@12,22:22='6',<NUMBER>,1:22]
[@13,31:30='<EOF>',<EOF>,2:0]

➜ grun Calc calc -gui
1 + 2 * (3 + 4) - 5 / 6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

lexer grammar CalcLexerRules;

PERCENT_NUMBER: NUMBER PERCENT;
NUMBER: DIGIT (POINT DIGIT)?;

DIGIT: [0-9]+;
BRACKET_L: '(';
BRACKET_R: ')';
ADD: '+';
SUB: '-';
MUL: '*';
DIV: '/';
PERCENT: '%';
POINT: '.';

WS: [ \t\r\n]+ -> skip;

1
2
3
4
5
6
7
8
9
10

grammar Calc;
import CalcLexerRules;  // 引入CalcLexerRules的词法规则

calc: (expr)* EOF;

expr:
    BRACKET_L expr BRACKET_R
    | (ADD | SUB)? (NUMBER | PERCENT_NUMBER)
    | expr (MUL | DIV) expr
    | expr (ADD | SUB) expr;

1
2
3
4
5
6
7
8
9
10
11
12
13

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

public class CalcTest {
    public static void main(String[] args) throws Exception {
        CalcLexer lexer = new CalcLexer(CharStreams.fromString("1 + 2 * (3 + 4) - 5 / 6"));
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        CalcParser parser = new CalcParser(tokens);
        ParseTree tree = parser.calc();
        System.out.println(tree.toStringTree(parser));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

grammar Calc;
@header {
package com.nosuchfield.calc.code;
}
import CalcLexerRules; // 引入词法分析文件

calc: (expr)* EOF # calculationBlock;

expr:
    BRACKET_L expr BRACKET_R                                # expressionWithBr
    | sign = (ADD | SUB)? num = (NUMBER | PERCENT_NUMBER)   # expressionNumeric
    | expr op = (MUL | DIV) expr                            # expressionMulOrDiv
    | expr op = (ADD | SUB) expr                            # expressionAddOrSub;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

package com.nosuchfield.calc;

import com.nosuchfield.calc.code.CalcBaseVisitor;
import com.nosuchfield.calc.code.CalcLexer;
import com.nosuchfield.calc.code.CalcParser;
import org.antlr.v4.runtime.Token;

import java.math.BigDecimal;
import java.math.MathContext;
import java.util.Objects;

public class CalculateVisitor extends CalcBaseVisitor<BigDecimal> {

    


    private static final MathContext MATH_CONTEXT = MathContext.DECIMAL128;

    


    @Override
    public BigDecimal visitCalculationBlock(CalcParser.CalculationBlockContext ctx) {
        BigDecimal calcResult = null;
        for (CalcParser.ExprContext expr : ctx.expr()) {
            calcResult = visit(expr);
        }
        return calcResult;
    }

    


    @Override
    public BigDecimal visitExpressionWithBr(CalcParser.ExpressionWithBrContext ctx) {
        return visit(ctx.expr());
    }

    



    @Override
    public BigDecimal visitExpressionMulOrDiv(CalcParser.ExpressionMulOrDivContext ctx) {
        BigDecimal left = visit(ctx.expr(0));
        BigDecimal right = visit(ctx.expr(1));
        switch (ctx.op.getType()) {
            case CalcParser.MUL:
                return left.multiply(right, MATH_CONTEXT);
            case CalcParser.DIV:
                return left.divide(right, MATH_CONTEXT);
            default:
                throw new RuntimeException("unsupported operator type");
        }
    }

    



    @Override
    public BigDecimal visitExpressionAddOrSub(CalcParser.ExpressionAddOrSubContext ctx) {
        BigDecimal left = visit(ctx.expr(0));
        BigDecimal right = visit(ctx.expr(1));
        switch (ctx.op.getType()) {
            case CalcParser.ADD:
                return left.add(right, MATH_CONTEXT);
            case CalcParser.SUB:
                return left.subtract(right, MATH_CONTEXT);
            default:
                throw new RuntimeException("unsupported operator type");
        }
    }

    



    @Override
    public BigDecimal visitExpressionNumeric(CalcParser.ExpressionNumericContext ctx) {
        BigDecimal numeric = numberOrPercent(ctx.num);
        if (Objects.nonNull(ctx.sign) && ctx.sign.getType() == CalcLexer.SUB) {
            return numeric.negate();
        }
        return numeric;
    }

    


    private BigDecimal numberOrPercent(Token num) {
        String numberStr = num.getText();
        switch (num.getType()) {
            case CalcLexer.NUMBER:
                return new BigDecimal(numberStr);
            case CalcLexer.PERCENT_NUMBER:
                return new BigDecimal(numberStr.substring(0, numberStr.length() - 1).trim())
                        .divide(BigDecimal.valueOf(100), MATH_CONTEXT);
            default:
                throw new RuntimeException("unsupported number type");
        }
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

package com.nosuchfield.calc;

import com.nosuchfield.calc.code.CalcLexer;
import com.nosuchfield.calc.code.CalcParser;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.junit.Test;

import java.math.BigDecimal;

import static junit.framework.TestCase.assertEquals;

public class TestCalculate {

    @Test
    public void testCalculate() {
        String[][] sources = new String[][]{
                {"1 + 2", "3"},
                {"3 - 2", "1"},
                {"2 * 3", "6"},
                {"6 / 3", "2"},
                {"6 / (1 + 2)", "2"},
                {"50%", "0.5"},
                {"100 * 30%", "30.0"},
                {"1 + 2 * (3 - 4) / 5", "0.6"},
                {"-8 + 8 * 2 - 8", "0"}
        };
        for (String[] source : sources) {
            String input = source[0].trim();
            BigDecimal result = new BigDecimal(source[1].trim());
            assertEquals(calculate(input), result);
        }
    }

    





    private BigDecimal calculate(String expression) {
        CharStream cs = CharStreams.fromString(expression);
        CalcLexer lexer = new CalcLexer(cs);
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        CalcParser parser = new CalcParser(tokens);
        CalcParser.CalcContext context = parser.calc();
        CalculateVisitor visitor = new CalculateVisitor();
        return visitor.visit(context);
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13

grammar Csv;

@header {
package com.nosuchfield.csv.code;
}

csv: hdr row*;
hdr: row;
row: field (',' field)* '\r'? '\n';
field: TEXT # text | STRING # string | # empty;

TEXT: ~[\n,\r]+;
STRING: '"' ('""' | ~'"')* '"';

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

package com.nosuchfield.csv;

import com.nosuchfield.csv.code.CsvBaseListener;
import com.nosuchfield.csv.code.CsvParser;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class CsvListener extends CsvBaseListener {

    


    private final List<Map<String, String>> rows = new ArrayList<>();

    


    private List<String> header;

    


    private List<String> row;

    


    @Override
    public void enterRow(CsvParser.RowContext ctx) {
        
        row = new ArrayList<>();
    }

    


    @Override
    public void exitText(CsvParser.TextContext ctx) {
        
        row.add(ctx.TEXT().getText());
    }

    @Override
    public void exitString(CsvParser.StringContext ctx) {
        
        String field = ctx.STRING().getText();
        
        field = field.substring(1, field.length() - 2);
        
        field = field.replaceAll("\"\"", "\"");
        row.add(field);
    }

    @Override
    public void exitEmpty(CsvParser.EmptyContext ctx) {
        
        row.add("");
    }

    


    @Override
    public void exitRow(CsvParser.RowContext ctx) {
        if (ctx.getParent() instanceof CsvParser.HdrContext) {
            
            
            header = row;
            return;
        }
        Map<String, String> data = new HashMap<>();
        
        for (int i = 0; i < row.size(); i++) {
            data.put(header.get(i), row.get(i));
        }
        
        rows.add(data);
    }

    public List<Map<String, String>> getRows() {
        return rows;
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public void testCsv() throws IOException {
    
    CsvLexer lexer = new CsvLexer(CharStreams.fromFileName("src/main/resources/csv/city.csv"));
    
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    
    CsvParser parser = new CsvParser(tokens);
    
    ParseTree tree = parser.csv();
    
    System.out.println(tree.toStringTree(parser));

    
    ParseTreeWalker parseTreeWalker = new ParseTreeWalker();
    
    CsvListener listener = new CsvListener();
    
    parseTreeWalker.walk(listener, tree);
    
    System.out.println(listener.getRows());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

public class CalculateListener extends CalcBaseListener {

    private static final MathContext MATH_CONTEXT = MathContext.DECIMAL128;

    private Stack<BigDecimal> stack;

    private BigDecimal result;

    @Override
    public void enterCalculationBlock(CalcParser.CalculationBlockContext ctx) {
        
        stack = new Stack<>();
    }

    @Override
    public void exitCalculationBlock(CalcParser.CalculationBlockContext ctx) {
        
        result = stack.pop();
    }

    @Override
    public void exitExpressionMulOrDiv(CalcParser.ExpressionMulOrDivContext ctx) {
        
        BigDecimal x = stack.pop();
        BigDecimal y = stack.pop();
        BigDecimal z;
        switch (ctx.op.getType()) {
            case CalcLexer.MUL:
                z = y.multiply(x, MATH_CONTEXT);
                break;
            case CalcLexer.DIV:
                z = y.divide(x, MATH_CONTEXT);
                break;
            default:
                throw new RuntimeException("unsupported operator type");
        }
        stack.push(z);
    }

    @Override
    public void exitExpressionAddOrSub(CalcParser.ExpressionAddOrSubContext ctx) {
        
        BigDecimal x = stack.pop();
        BigDecimal y = stack.pop();
        BigDecimal z;
        switch (ctx.op.getType()) {
            case CalcLexer.ADD:
                z = y.add(x, MATH_CONTEXT);
                break;
            case CalcLexer.SUB:
                z = y.subtract(x, MATH_CONTEXT);
                break;
            default:
                throw new RuntimeException("unsupported operator type");
        }
        stack.push(z);
    }

    @Override
    public void exitExpressionNumeric(CalcParser.ExpressionNumericContext ctx) {
        
        BigDecimal numeric = numberOrPercent(ctx.num);
        if (Objects.nonNull(ctx.sign) && ctx.sign.getType() == CalcLexer.SUB) {
            numeric = numeric.negate();
        }
        stack.push(numeric);
    }

    private BigDecimal numberOrPercent(Token num) {
        String numberStr = num.getText();
        switch (num.getType()) {
            case CalcLexer.NUMBER:
                return new BigDecimal(numberStr);
            case CalcLexer.PERCENT_NUMBER:
                return new BigDecimal(numberStr.substring(0, numberStr.length() - 1).trim())
                        .divide(BigDecimal.valueOf(100), MATH_CONTEXT);
            default:
                throw new RuntimeException("unsupported number type");
        }
    }

    




    public BigDecimal getResult() {
        return result;
    }

}