lr(0)语法分析器java

您好！lr(0)语法分析器是一种自下而上的语法分析器，它可以用于对文法进行自动分析和语法检查。在Java中，可以使用ANTLR框架来实现lr(0)语法分析器。ANTLR是一种高性能的语法分析器生成器，它可以根据语法文件自动生成语法分析器。以下是一个简单的lr(0)语法分析器的Java代码示例：

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

public class MyParser {
    public static void main(String[] args) throws Exception {
        String input = "1+2*3";
        ANTLRInputStream inputStream = new ANTLRInputStream(input);
        MyLexer lexer = new MyLexer(inputStream);
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        MyParser parser = new MyParser(tokens);
        ParseTree tree = parser.expr();
        System.out.println(tree.toStringTree(parser));
    }
}

class MyLexer extends Lexer {
    public static int PLUS = 1;
    public static int MULT = 2;
    public static int INT = 3;

    public MyLexer(CharStream input) {
        super(input);
    }

    public Token nextToken() {
        if (_input.LA(1) == '+') {
            consume();
            return new CommonToken(PLUS, "+");
        } else if (_input.LA(1) == '*') {
            consume();
            return new CommonToken(MULT, "*");
        } else if (_input.LA(1) >= '0' && _input.LA(1) <= '9') {
            int start = _input.index();
            while (_input.LA(1) >= '0' && _input.LA(1) <= '9') {
                consume();
            }
            return new CommonToken(INT, _input.getText(start, _input.index() - 1));
        } else {
            throw new RuntimeException("Invalid character: " + (char)_input.LA(1));
        }
    }
}

class MyParser extends Parser {
    public MyParser(TokenStream input) {
        super(input);
    }

    public ParseTree expr() {
        ParseTree left = term();
        while (true) {
            if (match(MyLexer.PLUS)) {
                ParseTree right = term();
                left = new PlusExpr(left, right);
            } else {
                break;
            }
        }
        return left;
    }

    public ParseTree term() {
        ParseTree left = factor();
        while (true) {
            if (match(MyLexer.MULT)) {
                ParseTree right = factor();
                left = new MultExpr(left, right);
            } else {
                break;
            }
        }
        return left;
    }

    public ParseTree factor() {
        Token token = match(MyLexer.INT);
        return new IntExpr(Integer.parseInt(token.getText()));
    }

    public Token match(int type) {
        Token token = _input.LT(1);
        if (token.getType() == type) {
            consume();
            return token;
        } else {
            throw new RuntimeException("Expecting " + getTokenName(type) + "; found " + token.getText());
        }
    }
}

abstract class Expr extends RuleContext {
    public abstract int eval();
}

class PlusExpr extends Expr {
    private ParseTree left;
    private ParseTree right;

    public PlusExpr(ParseTree left, ParseTree right) {
        this.left = left;
        this.right = right;
    }

    public int eval() {
        return ((Expr)left).eval() + ((Expr)right).eval();
    }

    public String toString() {
        return "(" + left.toString() + " + " + right.toString() + ")";
    }
}

class MultExpr extends Expr {
    private ParseTree left;
    private ParseTree right;

    public MultExpr(ParseTree left, ParseTree right) {
        this.left = left;
        this.right = right;
    }

    public int eval() {
        return ((Expr)left).eval() * ((Expr)right).eval();
    }

    public String toString() {
        return "(" + left.toString() + " * " + right.toString() + ")";
    }
}

class IntExpr extends Expr {
    private int value;

    public IntExpr(int value) {
        this.value = value;
    }

    public int eval() {
        return value;
    }

    public String toString() {
        return Integer.toString(value);
    }
}

这段代码实现了一个简单的四则运算解析器，可以识别表达式中的加号、乘号和整数，并计算表达式的值。您可以根据自己的需求修改代码来实现自己的lr(0)语法分析器。