识别彼此相邻的无限'{'expr'}'的语法

Question

我正在使用 ANTLR4 编写一个 C# 应用程序来识别以下 TeX'ish 风格：

{a}{x}+{b}{y}+{c}

我当前的语法总是采用 '{' expr '}' 的最后一个实例，然后忽略字符串的开头。以下是当前语法的一些输出结果（如下所述）：

• 输入： {a} 输出： a [通过]
• 输入： {a}+{x} 输出： a + x [通过]
• 输入： {a}{x} 输出： x [失败] 期望： ax
• 输入： {a}{x}+{b} 输出： x + b [失败] 期望： ax + b
• 输入： {a}{x}+{b}{y} 输出： y [失败] 期望： ax + by
• 输入： {a}{x}+{b}{y}+{c} 输出： y + c [失败] 期望： ax + by + c
• 输入： {a}{x}+{b}{y}+{c}{d} 输出： d [失败] 期望： ax + by + cd

关于如何解决这个问题的任何想法？

Grammar MyGra.g4 文件：

/*
 * Parser Rules
 */
prog: expr+ ;

expr : '{' expr '}'                 # CB_Expr
     | expr op=('+'|'-') expr       # AddSub
     | '{' ID '}'                   # CB_ID
     | ID                           # ID
     ;

/*
 * Lexer Rules
 */
ID: ('a' .. 'z' | 'A' .. 'Z')+;
ADD : '+';
SUB : '-';
WS:   (' ' | '\r' | '\n') -> channel(HIDDEN);

MyGraVisitor.CS 文件：

 public override string VisitID(MyGraParser.IDContext context)
 {
      return context.ID().GetText();
 }

 public override string VisitAddSub(MyGraParser.AddSubContext context)
 {
     if (context.op.Type == MyGraParser.ADD)
     {
         return Visit(context.expr(0)) + " + " + Visit(context.expr(1));
     }
     else
     {
         return Visit(context.expr(0)) + " - " + Visit(context.expr(1));
     }
 }

 public override string VisitCB_Expr(MyGraParser.CB_ExprContext context)
 {
     return Visit(context.expr());
 }

 public override string VisitCB_ID(MyGraParser.CB_IDContext context)
 {
     return context.ID().GetText();
 }

更新#1：

有人建议为

包含一个语法规则

'{' expr '}{' expr '}'

但是，如果我有 {a}{b}{c}{d}+{e}{f}{g}，我认为语法应该通过解析树解释“自身”的递归版本。 .. 那么如果我有 1000 个 {expr} 彼此相邻怎么办？那我需要多少条规则？我认为这个建议是有效的，除了我不确定如何计算彼此相邻的无限量的 {expr}？

我的另一个问题是：如何重新使用规则 CB_Expr？

更新#2：

我添加了规则：

| expr CB_Expr                  # CB_Expr2

与访客：

public override string VisitCB_Expr2(MyGra.CB_Expr2Context context)
{
    return Visit(context.expr()) + Visit(context.CB_Expr());
}

那没有帮助，我仍然在所有情况下得到相同的输出（如上所述）。

Answer 1

你的语法有歧义。例如：输入 {x} 可以有两个不同的解析树（如 Mephy 所说）：

(CB_Expr { (expr (ID x)) })

和

（DB_ID {x}）

删除 CB_ID 将解决此问题，而实际上不会做任何负面的事情。

对于你的实际问题，这应该可以解决 expr:

expr : left=id_expr op=('+' |'-') right=expr #AddSub
     | id_expr                               #ID_Expr
     ;

id_expr :
     | '{' ID '}' id_expr                    #ID_Ex
     | '{' ID '}'                            #ID
     ;

我还没有测试过这个，我也没有给你写过任何访问者，但是语法应该可以。

id_expr 规则以递归方式工作，因此您应该能够根据需要将尽可能多的 {ID} 放在彼此之后 - 至少一个，但语法现在的方式。