哈喽！今天心血来潮给大家带来了《编写自定义错误处理程序在ANTLR的Go目标中》，想必大家应该对Golang都不陌生吧，那么阅读本文就都不会很困难，以下内容主要涉及到，若是你正在学习Golang，千万别错过这篇文章~希望能帮助到你！

我正在尝试将 antlr 项目从 c++ 迁移到 go。语法和代码生成大部分已经完成（基于 65038949 中提供的解决方案），但还有一个待完成的项目是在 go 中编写自定义错误报告器。

我正在寻找一个用于以下目的的自定义错误报告器：

1. 我想打印我的自定义消息，可能包含额外信息（例如文件名，默认错误打印机不会打印该消息）。

2. 对于每个错误，错误报告器都会更新全局计数器，并且在主程序中，如果此 error_count>0 则跳过进一步的处理。

以下是 c++ 项目中所做的事情：

1. 此函数中定义了自定义消息：

   string myerrormessage(unsigned int l, unsigned int p, string m) {
       stringstream s;
       s << "err: line " << l << "::" << p << " " << m;
       global->errors++;
       return s.str();
   }
   

2. antlr 运行时 (consoleerrorlistener.cpp) 已更新为调用上述函数：

   void consoleerrorlistener::syntaxerror(irecognizer *, token * ,
     size_t line, size_t charpositioninline, const std::string &msg, std::exception_ptr)  {
     std::cerr << myerrormessage(line, charpositioninline, msg) << std::endl;
   }
   

3. 最后，主程序将跳过进一步的处理，如下所示：

   parser.top_rule();
   if(global->errors > 0) {
       exit(0);
   }
   

如何为antlr的go目标重写这些c++代码？

浏览 antlr 运行时代码（来自 github.com/antlr/antlr4/runtime/go/antlr）后的一些附加说明：

• parser.go 有一个变量“_syntaxerrors”，它会在每次错误时递增，但似乎没有人使用它。该变量的用途是什么？解析后如何使用它来检查是否发生了任何错误？我做了以下操作，但显然这不起作用！ （解决方法是在解析器中添加一个新变量 myerrorcount，并在 _syntaxerrors 也增加时增加它，但这看起来不是一个优雅的解决方案，因为我在这里编辑运行时代码！）

  tree := parser.Top_rule() // this is ok
  fmt.Printf("errors=%d\n", parser._SyntaxErrors) // this gives a compiler error
  //fmt.Printf("errors=%d\n", parser.MyErrorCount) // this is ok
  

• 在上面的注释中，我在 antlr 代码中引入了一个新变量，并在用户代码中读取它 - 糟糕的编码风格，但有效。但我还需要做相反的事情 - antlr 错误报告器（error_listener.go:syntaxerror()）需要读取具有文件名的用户代码变量并打印它。我可以通过在 antlr 中添加一个新函数来传递此参数并将此文件名注册到新变量中来实现此目的，但是有更好的方法吗？

解决方案

antlr 很棒，但是，有一点需要注意的是，在错误处理方面，它不是 go 惯用的。这使得整个错误过程对于 golang 工程师来说不直观。

为了在每个步骤（词法分析、解析、行走）注入您自己的错误处理，您必须注入带有恐慌的错误侦听器/处理程序。恐慌和恢复非常类似于 java 异常，我认为这就是它如此设计的原因（antlr 是用 java 编写的）。

lex/parse 错误收集（容易做）

您可以根据需要实现任意数量的 errorlistener。使用的默认值是 ConsoleErrorListenerInstance。它所做的只是打印到 SyntaxErrors 上的 stderr，因此我们将其删除。自定义错误报告的第一步是替换它。我制作了一个基本的错误，仅收集自定义类型中的错误，以便稍后使用/报告。

type customsyntaxerror struct {
    line, column int
    msg          string
}

type customerrorlistener struct {
    *antlr.defaulterrorlistener // embed default which ensures we fit the interface
    errors []error
}

func (c *customerrorlistener) syntaxerror(recognizer antlr.recognizer, offendingsymbol interface{}, line, column int, msg string, e antlr.recognitionexception) {
    c.errors = append(c.errors, &customsyntaxerror{
        line:   line,
        column: column,
        msg:    msg,
    })
}

您可以在解析器/词法分析器上注入错误侦听器（同时清除默认侦听器）。

lexererrors := &customerrorlistener{}
lexer := newmylexer(is)
lexer.removeerrorlisteners()
lexer.adderrorlistener(lexererrors)

parsererrors := &customerrorlistener{}
parser := newmyparser(stream)
p.removeerrorlisteners()
p.adderrorlistener(parsererrors)

当词法分析/解析完成时，两个数据结构都会出现词法分析/解析阶段发现的语法错误。您可以使用 syntaxerror 中给出的字段进行操作。您必须在其他地方寻找其他接口函数，例如 reportambuiguity。

if len(lexererrors.errors) > 0 {
        fmt.printf("lexer %d errors found\n", len(lexererrors.errors))
        for _, e := range lexererrors.errors {
            fmt.println("\t", e.error())
        }
    }

    if len(parsererrors.errors) > 0 {
        fmt.printf("parser %d errors found\n", len(parsererrors.errors))
        for _, e := range parsererrors.errors {
            fmt.println("\t", e.error())
        }
    }

lex/parse 错误中止（不确定这有多可靠）

警告：这确实让人感觉很卡顿。如果只需要收集错误，就按上面所示的操作即可！

要中止 lex/parse，您必须在错误侦听器中引发恐慌。老实说，我不明白这个设计，但是词法分析/解析代码包含在恐慌恢复中，用于检查恐慌是否属于 recognitionexception 类型。此异常作为参数传递给您的 errorlistener，因此请修改 syntaxerror 表达式

func (c *customerrorlistener) syntaxerror(recognizer antlr.recognizer, offendingsymbol interface{}, line, column int, msg string, e antlr.recognitionexception) {
  // ...
  panic(e) // feel free to only panic on certain conditions. this stops parsing/lexing
}

这个紧急错误被捕获并传递给实现ErrorStrategy的errorhandler。我们关心的重要函数是recover()。恢复尝试从错误中恢复，消耗令牌流，直到找到预期的模式/令牌。既然我们希望这个中止，我们可以从 BailErrorStrategy 中获得灵感。这个策略仍然很糟糕，因为它使用恐慌来停止所有工作。您可以简单地省略实现。

type betterbailerrorstrategy struct {
    *antlr.defaulterrorstrategy
}

var _ antlr.errorstrategy = &betterbailerrorstrategy{}

func newbetterbailerrorstrategy() *betterbailerrorstrategy {

    b := new(betterbailerrorstrategy)

    b.defaulterrorstrategy = antlr.newdefaulterrorstrategy()

    return b
}

func (b *betterbailerrorstrategy) reporterror(recognizer antlr.parser, e antlr.recognitionexception) {
    // pass, do nothing
}


func (b *betterbailerrorstrategy) recover(recognizer antlr.parser, e antlr.recognitionexception) {
    // pass, do nothing
}

// make sure we don't attempt to recover from problems in subrules.//
func (b *betterbailerrorstrategy) sync(recognizer antlr.parser) {
    // pass, do nothing
}

然后添加到解析器

parser.SetErrorHandler(NewBetterBailErrorStrategy())

话虽这么说，我建议只收集听众的错误，而不是费心尝试提前中止。 bailerrorstrategy 似乎并没有真正发挥作用，而且在 golang 中使用恐慌来恢复感觉很笨拙，很容易搞砸。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。