使用Grappa (Java PEG解析器)匹配OR表达式

Question

我是PEG解析的新手，并试图编写一个简单的解析器来解析像"term1或term2另一个术语"这样的表达式，理想情况下将其解析为AST，看起来像:

          OR
-----------|---------
|                    |
"term1"            "term2 anotherterm"

我目前使用Grappa (https://github.com/fge/grappa)，但它不匹配甚至更基本的表达式"term1或term2"。这是我的文件:

package grappa;
import com.github.fge.grappa.annotations.Label;
import com.github.fge.grappa.parsers.BaseParser;
import com.github.fge.grappa.rules.Rule;
public class ExprParser extends BaseParser<Object> {
  @Label("expr")
  Rule expr() {
    return sequence(terms(), wsp(), string("OR"), wsp(), terms(), push(match()));
  }
  @Label("terms")
  Rule terms() {
    return sequence(whiteSpaces(),
        join(term()).using(wsp()).min(0),
        whiteSpaces());
  }
  @Label("term")
  Rule term() {
    return sequence(oneOrMore(character()), push(match()));
  }
  Rule character() {
    return anyOf(
        "0123456789" +
        "abcdefghijklmnopqrstuvwxyz" +
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +
        "-_");
  }
  @Label("whiteSpaces")
  Rule whiteSpaces() {
    return join(zeroOrMore(wsp())).using(sequence(optional(cr()), lf())).min(0);
  }
}

谁能给我指个正确的方向?

Answer 1

(作者的grappa这里…)

好的，那么，你似乎想要的实际上是一个解析树。

最近开发了一个grappa (2.0.x+)的扩展，可以满足您的需求:https://github.com/ChrisBrenton/grappa-parsetree.

默认情况下，

Grappa只"盲目"匹配文本，并有一个堆栈可供使用，因此您可以使用，例如:

public Rule oneOrOneOrEtc()
{
    return join(one(), push(match())).using(or()).min(1));
}

但是你所有的匹配项都会在堆栈上…不是很实用，但在某些情况下仍然可用(例如，参见sonar-sslr-grappa)。

在你的情况下，你需要这个包裹。你可以这样做:

// define your root node
public final class Root
    extends ParseNode
{
    public Root(final String match, final List<ParseNode> children)
    {
        super(match, children);
    }
}
// define your parse node
public final class Alternative
    extends ParseNode
{
    public Alternative(final String match, final List<ParseNode> children)
    {
        super(match, children);
    }
}

这是最小的实现。然后你的解析器看起来像这样:

@GenerateNode(Alternative.class)
public Rule alternative() // or whatever
{
    return // whatever an alternative is
}
@GenerateNode(Root.class)
public Rule root
{
    return join(alternative())
        .using(or())
        .min(1);
}

这里发生的事情是因为根节点在替代节点之前匹配，例如，如果您有一个字符串:

a or b or c or d

则根节点将匹配"整个序列"，并且它将有四个备选项分别匹配a, b, c和d。

感谢Christopher Brenton首先提出了这个想法!