0

我需要一个仅从文本文件中获取重要标记部分的解析器。这是示例输入：

else before 1
else before 2
--Start Query 1
important 1
--End 1
else between 1 and 2 - 1
else between 1 and 2 - 2
--Start Query 2
important 2
--End 2 
else after1-1
else after1-2

我写了这个解析器：

public class ExpressionDefinition extends GrammarDefinition {
        {
            def("start", ref("expr").star().end());
            def("nl",  of("\r\n").or(of("\n").or(of("\r"))));
            def("expr", 
                    ref("else").starLazy(ref("expr_start").flatten())
                    .seq(ref("expr_start"))
                    .seq(ref("expr_body"))
                    .seq(ref("expr_end"))
                    .seq(ref("else").starLazy(ref("expr_start")).optional()).map(in -> {
                        if (in instanceof List) {
                            for (Object o: (List)in) {
                                if (o instanceof Body) {
                                    return o;
                                } 
                            }
                        }
                        return null;
                    }));
            def("expr_start", of("--Start Query").seq(any().starLazy(ref("nl")), ref("nl")));
            def("expr_body", any().starLazy(ref("expr_end")).flatten().map((String in) -> new Body(in)));
            def("expr_end", of("--End").seq(any().starLazy(ref("nl")).optional(), ref("nl").optional()));
            def("else", any().starLazy(ref("nl")).seq(ref("nl")));
        }

使用这个小实用程序 Pojo 来获取重要数据：

@Data
@AllArgsConstructor
public static class Body {
    private final String val;
    @Override public String toString() { return val; }
}

像这样运行：

ExpressionDefinition def = new ExpressionDefinition();
Parser parser = def.build();
Result result = parser.parse(input);

它给了我一个例外： org.petitparser.context.ParseError: end of input expected 但没有明显的原因，因为最后一行是else一种内容，我们希望它具有星级条件，它是以下内容的一部分expr：ref("else").starLazy(ref("expr_start")).optional()

我如何更改解析器，所以它会期望 et 的结尾在输入的末尾expr有else或没有可能的换行符？使else贪婪使它消耗第二个expr_body。使其any().optional()导致无限循环挂起。有什么解决办法吗？

4

1 回答 1

1

可能您想使用a.delimitedBy(b)运算符，它为您提供了一个解析器，该解析器消耗a一个或多个时间，并可能由参数结束b。如果您需要更多控制，请查看它是如何实现的。

于 2021-07-15T19:44:32.650 回答