ISOGQL 的 Antlr4 使用及优化

grammar Expr;


// 定义表达式的语法规则
expr: term (op term)* ;
term: INT | '(' expr ')' ;
op: '+' | '-' | '*' | '/' ;


// 定义整数类型
INT: [0-9]+ ;
WS: [ \t\n\r]+ -> skip ;

antlr4 -Dlanguage=Python3 Expr.g4

from antlr4 import *
from ExprLexer import ExprLexer
from ExprParser import ExprParser


# 定义一个Visitor，用于处理表达式
class ExprVisitor(ParseTreeVisitor):
    # 处理表达式
    def visitExpr(self, ctx: ExprParser.ExprContext):
        return self.visitChildren(ctx)
    # 处理项
    def visitTerm(self, ctx: ExprParser.TermContext):
        if ctx.INT():
            return int(ctx.INT().getText())
        else:
            return self.visit(ctx.expr())
    # 处理操作符
    def visitOp(self, ctx: ExprParser.OpContext):
        return ctx.getText()
    # 处理子元素
    def visitChildren(self, node):
        results = []
        for child in node.getChildren():
            result = self.visit(child)
            if result is not None:
                results.append(result)
        return results
        
# 输入表达式
input_expr = "2 * (3 + 4)"


# 创建词法解析器和语法解析器
lexer = ExprLexer(InputStream(input_expr))
tokens = CommonTokenStream(lexer)
parser = ExprParser(tokens)


# 解析表达式
tree = parser.expr()


# 处理表达式
visitor = ExprVisitor()
result = visitor.visit(tree)
print(result)

MATCH (p:Person)-[r:IS_FRIENDS_WITH]->(friend:Person)
WHERE EXISTS (MATCH (p)-[:WORKS_FOR]->(:Company {name: "GQL, Inc."}))
RETURN p, r, friend

valueExpr: commonValueExpr | booleanValueExpr;


commonValueExpr:
  numericValueExpr
  | stringValueExpr
  | dateTimeValueExpr
  | durationValueExpr
  | listValueExpr
  | recordValueExpr
  | pathValueExpr
  | refValueExpr
  | commonValuePropertiesGroup;
 
numericValueExpr:
  term
  | term PLUS numericValueExpr
  | term MINUS numericValueExpr;


term: factor | factor ASTERISK term | factor SOLIDUS term;


factor: SIGN? numericPrimary;


numericPrimary: valueExprPrimary | numericValueFunction;


stringValueExpr: charStringValueExpr | byteStringValueExpr;


charStringFactor: charStringPrimary;


charStringPrimary: valueExprPrimary | stringValueFunction;


valueExprPrimary:
  parenthesizedValueExpr
  | nonParenthesizedValueExprPrimary;

expression
   : NOT expression                             
   | lhs = expression AND rhs = expression      
   | lhs = expression XOR rhs = expression      
   | lhs = expression OR rhs = expression      
   | expressionPredicate                        
   ;


expressionPredicate
   : expressionPredicate IS NOT? truthValue                                      
   | lhs = expressionPredicate compOp rhs = expressionPredicate                  
   | ...
   | expressionAtom
   ;


expressionAtom
   : LEFT_PAREN expression RIGHT_PAREN     
   | ...
   | unsignedLiteral 
   | ...
   ;