logo标签列表

ANTLR + Scala: 有哪些改进的想法？

javascalaantlr4
4
我正在尝试找到一种在Scala领域中集成antlr解析器的方法。
我尝试使用用于从解析树构建Scala对象的Scala编写的访问者，但是要求具有统一返回类型的限制不可行。
因此，我决定冒险并直接从解析器操作中构建Scala对象，使用Scala类的Java接口。
这篇博客文章非常有帮助：

http://blog.akquinet.de/2011/07/20/integrating-scala-components-in-a-java-application/

这是我得到的：

Scala AST DSL

package toylang.ast

trait TypeExpr
case object IntType extends TypeExpr
case object BoolType extends TypeExpr

trait Expr
case class Ident(name: String) extends Expr
case class IntNum(repr: String) extends Expr
case object True extends Expr
case object False extends Expr
case class Plus(e: Expr) extends Expr
case class Minus(e: Expr) extends Expr
case class Add(l: Expr, r: Expr) extends Expr
case class Sub(l: Expr, r: Expr) extends Expr
case class Mul(l: Expr, r: Expr) extends Expr
case class Div(l: Expr, r: Expr) extends Expr
case class Pow(e: Expr, exponent: Expr) extends Expr
case class Not(e: Expr) extends Expr
case class And(l: Expr, r: Expr) extends Expr
case class Or(l: Expr, r: Expr) extends Expr
case class Implies(l: Expr, r: Expr) extends Expr

case class Ite(c: Expr, t: Expr, eif: List[Elsif], e:Expr) extends Expr
case class Elsif(c: Expr, t: Expr) 

case class Neq(l: Expr, r: Expr) extends Expr
case class Eq(l: Expr, r: Expr) extends Expr
case class Lt(l: Expr, r: Expr) extends Expr
case class Le(l: Expr, r: Expr) extends Expr
case class Gt(l: Expr, r: Expr) extends Expr
case class Ge(l: Expr, r: Expr) extends Expr

trait Stmt
case class DefStmt(id: Ident, t: TypeExpr, e: Expr) extends Stmt

antlr语法，使用Java操作调用Scala构造函数

grammar ToyLang;

// lexer customized header
@lexer::header{
package toylang.parser.antlr;
}

// parser customized header
@parser::header{
package toylang.parser.antlr;
import toylang.ast.*;
import java.util.List;
import java.util.ArrayList;
import utils.Fun;
import utils.Conv;
}

@parser::members {

// a class which extracts an object from a context an can be mapped over a java list.
Fun defStmtMap = new Fun<DefStmtContext, Stmt> () {
    public Stmt apply(DefStmtContext ctx) {
        return ctx.result;
    }
};

// a class which extracts an object from a context an can be mapped over a java list.
Fun elsifMap = new Fun<ElsifContext, Elsif> () {
    public Elsif apply(ElsifContext ctx) {
        return ctx.result;
    }
};

}

program returns [scala.collection.immutable.List<Stmt> result]
    : sl+=defStmt sl+=defStmt* EOF { 
            $result = Conv.scalaList(Conv.map($sl, defStmtMap)); 
        }
    ;

type returns[TypeExpr result]
    : 'int'  { $result = IntType$.MODULE$; }
    | 'bool' { $result = IntType$.MODULE$; }
    ;

defStmt returns[Stmt result]
    : id=ident ':' t=type  op=DEFINE e=expr ';' { 
            $result = DefStmt$.MODULE$.apply($id.ctx.result, $t.ctx.result, $e.ctx.result); 
        }
    ; 

expr returns[Expr result]
    : lit=TRUE
        { $result = True$.MODULE$; }

    | lit=FALSE
        { $result = False$.MODULE$; }                        

    | lit=INT_LIT
        { $result = IntNum$.MODULE$.apply($lit.text); }        

    | id=ident
        { $result = $id.ctx.result; }

    | op='(' e=expr ')'
        { $result = $e.ctx.result; }

    | IF c=expr THEN t=expr ei+=elsif* ELSE e=expr 
        {
            scala.collection.immutable.List<Elsif> l = Conv.scalaList(Conv.map($ei, elsifMap)); 
            $result = Ite$.MODULE$.apply($c.ctx.result, $t.ctx.result, l, $e.ctx.result);
        }

    | op=(ADD|SUB) e=expr
        { 
            switch($op.type) {
                case ADD : $result = Plus$.MODULE$.apply($e.ctx.result); break;  
                case SUB : $result = Minus$.MODULE$.apply($e.ctx.result); break;  
            }
        }

    |<assoc=right> l=expr op=CARRET r=expr  
        { $result = Pow$.MODULE$.apply($l.ctx.result, $r.ctx.result); }

    |<assoc=left> l=expr op=(STAR|SLASH) r=expr  
        { 
            switch($op.type) {
                case STAR : $result = Mul$.MODULE$.apply($l.ctx.result, $r.ctx.result); break;  
                case SLASH : $result = Div$.MODULE$.apply($l.ctx.result, $r.ctx.result); break;  
            }
        }
    |<assoc=left> l=expr op=(ADD|SUB) r=expr 
        {
            switch($op.type) {
                case ADD : $result = Add$.MODULE$.apply($l.ctx.result, $r.ctx.result); break;  
                case SUB : $result = Sub$.MODULE$.apply($l.ctx.result, $r.ctx.result); break;  
            }
        }
    | l=expr op=(NEQ|EQ|LT|LE|GT|GE) r=expr
        {
            switch($op.type) {
                case NEQ : $result = Neq$.MODULE$.apply($l.ctx.result, $r.ctx.result); break;  
                case EQ : $result = Eq$.MODULE$.apply($l.ctx.result, $r.ctx.result); break;  
                case LT : $result = Lt$.MODULE$.apply($l.ctx.result, $r.ctx.result); break;  
                case LE : $result = Le$.MODULE$.apply($l.ctx.result, $r.ctx.result); break;  
                case GT : $result = Gt$.MODULE$.apply($l.ctx.result, $r.ctx.result); break;  
                case GE : $result = Ge$.MODULE$.apply($l.ctx.result, $r.ctx.result); break;  
            }
        }

    | op=NOT e=expr
        { $result = Not$.MODULE$.apply($e.ctx.result); }

    |<assoc=left> l=expr op=AND r=expr
        { $result = And$.MODULE$.apply($l.ctx.result, $r.ctx.result); }

    |<assoc=left> l=expr op=OR r=expr
        { $result = Or$.MODULE$.apply($l.ctx.result, $r.ctx.result); }

    |<assoc=left> l=expr op=IMPLIES r=expr
        { $result = Implies$.MODULE$.apply($l.ctx.result, $r.ctx.result); }
    ;

elsif returns[Elsif result]
    : op=ELSIF c=expr THEN t=expr 
        {
            $result = Elsif$.MODULE$.apply($c.ctx.result, $t.ctx.result);
        }
    ;

ident returns [Ident result]
        : IDENT { $result = Ident$.MODULE$.apply($IDENT.text); }
        ;
LT: '<' ;
LE: '<=' ;
GT: '>' ;
GE: '>=' ;
EQ: '=' ;
NEQ: '!=' ;
ADD: '+';
AND: 'and';
DEFINE: ':=';
CARRET: '^';
ELSE: 'else';
ELSIF: 'elsif';
FALSE: 'false';
IF: 'if';
IMPLIES: 'implies';
KW_BOOL: 'bool';
KW_INT: 'int';
NOT: 'not';
OR: 'or';
SLASH: '*';
STAR: '*';
SUB: '-';
THEN: 'then';
TRUE: 'true';

INT_LIT
    :'0' 
    |[1-9][0-9]*
    ; 

IDENT:[_a-zA-Z][_a-zA-Z0-9]*;
WS: [ \t\f\r\n]+ -> skip;
//NL: '\r'? \n;

最后是两个Java实用程序类，Conv和Fun。Conv包含将Java列表转换为类型良好的Scala列表的代码，Fun是在将Java列表转换为Scala列表之前映射到Java列表上的操作的接口。

package utils;

import java.util.List;
import java.util.ArrayList;

public final class Conv<A, B> {

    public static <T> scala.collection.immutable.List<T> scalaList(List<T> javaList) {
        return scala.collection.JavaConversions.iterableAsScalaIterable(javaList).toList();
    }

    public static <A,B> List<B> map(List<A> from, Fun<A,B> convert) {

        ArrayList<B> res = new ArrayList<B>();

        for (A fromElem : from) {
            res.add(convert.apply(fromElem));
        }
        return res;
    }   
}

package utils;

public interface Fun<A, B> {
    B apply(A input);
}

调用antlr解析器的Scala代码：

package toylang.parser

import org.antlr.v4.runtime._
import org.antlr.v4.runtime.tree._
import org.stringtemplate.v4._
import toylang.parser.antlr._
import java.io.FileInputStream
import scala.collection.JavaConverters._


class Parser( arg: String ) {
  val input = new ANTLRInputStream(new FileInputStream(arg))
  val lexer = new ToyLangLexer(input)
  val tokens = new CommonTokenStream(lexer)
  val parser = new ToyLangParser(tokens)
  val prog = parser.program
  println (prog.result)
}

任何关于从Java转换为Scala的extract-results-from-contex-java-to-scala列表转换的改进想法都将受到欢迎。使其完全通用将是很好的，也许可以使用Java反射API。理想情况下，我希望使用一个语句从这个列表中的每个antlr规则上下文对象（或标记）中提取名为“foo”的字段，并将结果转换为Scala列表。
我已经在网络上搜索了很久，但没有找到如何做到这一点的教程。
问候，
http://codereview.stackexchange.com/ - Reimeus
你也可以考虑使用一些其他的解析器库，例如Parboiled (http://parboiled.org)、Parboiled2 (https://github.com/sirthias/parboiled2)或标准库中的Parser combinators，而不是使用ANTLR生成的语法。 - Martijn
嗨Martijn， 我从未尝试过parboiled，如果速度和内存消耗比scala的组合器更好，它可能是一个解决方案。实际上，出于性能和可读性/可维护性的原因，我正在尝试摆脱scala组合器。 我还尝试了scala-bison，也很不错，但我从来没有擅长解决shift/reduce或reduce/reduce冲突。 - remi
3个回答
2
答案一直在我眼前，而我却太盲目了，没有看到它：监听器。
更新语法和本地定义，以便 scala 对象可以存储：
grammar ToyLang2;

@lexer::header{
package toylang.parser.antlr;
}

@parser::header{
package toylang.parser.antlr;
import toylang.ast.*; // import scala ast symbols
}

program 
locals [scala.collection.immutable.List<Stmt> result]
    : sl+=defStmt sl+=defStmt* EOF 
    ;

type 
locals [TypeExpr result]
    : 'int'  # IntType
    | 'bool' # BoolType
    ;

defStmt 
locals[Stmt result]
    : id=ident ':' t=type  d=def? ';'
    ; 

def
locals [Expr result]
    : op=DEFINE e=expr
    ;

expr 
locals[Expr result]
    : e=boolNum                                     #BoolNumExpr
    | e=intNum                                      #IntNumxpr
    | e=ident                                       #IdentExpr
    | op='(' e=expr ')'                             #ParenExpr
    | IF c=expr THEN t=expr ei+=elsif* ELSE e=expr  #IteExpr
    | op=(ADD|SUB) e=expr                           #UnopArithExpr
    |<assoc=right> l=expr op=CARRET r=expr          #PowerExpr
    |<assoc=left> l=expr op=(STAR|SLASH) r=expr     #MulDivExpr
    |<assoc=left> l=expr op=(ADD|SUB) r=expr        #AddSubExpr
    | l=expr op=(NEQ|EQ|LT|LE|GT|GE) r=expr         #RelExpr
    | op=NOT e=expr                                 #NotExpr
    |<assoc=left> l=expr op=AND r=expr              #AndExpr
    |<assoc=left> l=expr op=OR r=expr               #OrExpr
    |<assoc=left> l=expr op=IMPLIES r=expr          #ImpliesExpr
    ;

elsif 
locals [Elsif result]
    : op=ELSIF c=expr THEN t=expr 
    ;

ident
locals [Ident result]
    : id=IDENT
    ;

intNum
locals [IntNum result]
    : num=INT_NUM 
    ;

boolNum
locals [BoolNum result]
    : num=(TRUE | FALSE)
    ;

LT: '<' ;
LE: '<=' ;
GT: '>' ;
GE: '>=' ;
EQ: '=' ;
NEQ: '!=' ;
ADD: '+';
AND: 'and';
DEFINE: ':=';
CARRET: '^';
ELSE: 'else';
ELSIF: 'elsif';
FALSE: 'false';
IF: 'if';
IMPLIES: 'implies';
KW_BOOL: 'bool';
KW_INT: 'int';
NOT: 'not';
OR: 'or';
SLASH: '*';
STAR: '*';
SUB: '-';
THEN: 'then';
TRUE: 'true';
INT_NUM :'0' |[1-9][0-9]* ; 
IDENT:[_a-zA-Z][_a-zA-Z0-9]* ;
WS: [ \t\f\r\n]+ -> skip;
//NL: '\r'? \n;

还有一个单一的Scala监听器：

package toylang.parser.antlr
import toylang.ast._
import scala.collection.JavaConversions._

class Listener extends ToyLang2BaseListener {

  // stores the result of a successfull parse
  var result: Option[List[Stmt]] = None 

  override def exitBoolNum(ctx: ToyLang2Parser.BoolNumContext ): Unit = {
    ctx.result = BoolNum(ctx.num.getText)
  }

  override def exitImpliesExpr(ctx: ToyLang2Parser.ImpliesExprContext ): Unit = {
    ctx.result = Implies (ctx.l.result, ctx.r.result)
  }

  override def exitAddSubExpr(ctx: ToyLang2Parser.AddSubExprContext ): Unit = { 
    import ToyLang2Parser.{ADD, SUB}
    ctx.result = ctx.op.getType match {
      case ADD => Add(ctx.l.result, ctx.r.result)
      case SUB => Sub(ctx.l.result, ctx.r.result)
    }
  }

  override def exitIteExpr(ctx: ToyLang2Parser.IteExprContext ): Unit = { 
    // using views to avoid creation of intermediate data
    val elsifList = ctx.ei.view  map { _.result } 
    ctx.result = Ite(ctx.c.result, ctx.t.result, elsifList.toList, ctx.e.result)
  }

  override def exitBoolNumExpr(ctx: ToyLang2Parser.BoolNumExprContext ): Unit = {
    ctx.result = ctx.e.result
  }

  override def exitParenExpr(ctx: ToyLang2Parser.ParenExprContext ): Unit = {
    ctx.result = ctx.e.result
  }

  override def exitPowerExpr(ctx: ToyLang2Parser.PowerExprContext ): Unit = { 
    ctx.result = Pow(ctx.l.result, ctx.r.result)
  }

  override def exitIntNum(ctx: ToyLang2Parser.IntNumContext ): Unit = {
    ctx.result = IntNum(ctx.num.getText)
  }

  override def exitIdentExpr(ctx: ToyLang2Parser.IdentExprContext ): Unit = { 
    ctx.result = ctx.e.result
  }

  override def exitNotExpr(ctx: ToyLang2Parser.NotExprContext ): Unit = { 
    ctx.result = Not(ctx.e.result)
  }

  override def exitElsif(ctx: ToyLang2Parser.ElsifContext ): Unit = { 
    ctx.result = Elsif(ctx.c.result, ctx.t.result)
  }

  override def exitBoolType(ctx: ToyLang2Parser.BoolTypeContext ): Unit = { 
    ctx.result = BoolType
  }

  override def exitIdent(ctx: ToyLang2Parser.IdentContext ): Unit = { 
    ctx.result = Ident(ctx.id.getText)
  }

  override def exitAndExpr(ctx: ToyLang2Parser.AndExprContext ): Unit = { 
    ctx.result = And(ctx.l.result, ctx.r.result)
  }


  override def exitOrExpr(ctx: ToyLang2Parser.OrExprContext ): Unit = { 
    ctx.result = Or(ctx.l.result, ctx.r.result)
}

  override def exitDef(ctx: ToyLang2Parser.DefContext ): Unit = { 
    ctx.result = ctx.e.result
  }

  override def exitProgram(ctx: ToyLang2Parser.ProgramContext ): Unit = {
    ctx.result = (ctx.sl.view  map { _.result }).toList
    result = Some(ctx.result)

  }

  override def exitIntType(ctx: ToyLang2Parser.IntTypeContext ): Unit = { 
    ctx.result = IntType
  }

  override def exitMulDivExpr(ctx: ToyLang2Parser.MulDivExprContext ): Unit = { 
    import ToyLang2Parser.{STAR,SLASH}
    ctx.result = ctx.op.getType match {
      case STAR => Mul(ctx.l.result, ctx.r.result)
      case SLASH => Div(ctx.l.result, ctx.r.result)
    }
  }

  override def exitUnopArithExpr(ctx: ToyLang2Parser.UnopArithExprContext ): Unit = { 
    import ToyLang2Parser.{ADD, SUB}
    ctx.result = ctx.op.getType match {
      case ADD => Plus(ctx.e.result)
      case SUB => Minus(ctx.e.result)
    }
  }

  override def exitIntNumxpr(ctx: ToyLang2Parser.IntNumxprContext ): Unit = { 
    ctx.result = ctx.e.result
  }

  override def exitDefStmt(ctx: ToyLang2Parser.DefStmtContext ): Unit = { 
    val d = ctx.d match {
      case null => None
      case e@_ => Some(e.result)
    }
    ctx.result = DefStmt(ctx.id.result, ctx.t.result, d)
  }

  override def exitRelExpr(ctx: ToyLang2Parser.RelExprContext ): Unit = { 
    import ToyLang2Parser.{NEQ,EQ,LT,LE,GT,GE}
    ctx.op.getType match {
      case NEQ => Neq(ctx.l.result, ctx.r.result)
      case EQ => Eq(ctx.l.result, ctx.r.result)
      case LT => Lt(ctx.l.result, ctx.r.result)
      case LE => Le(ctx.l.result, ctx.r.result)
      case GT => Gt(ctx.l.result, ctx.r.result)
      case GE => Ge(ctx.l.result, ctx.r.result)
    }
  }
}

最后，从Scala实例化ANTLR解析器并注册Scala监听器：
package toylang.parser
import toylang.parser.antlr.{Listener, ToyLang2Lexer, ToyLang2Parser}
import org.antlr.v4.runtime.{ANTLRInputStream, CommonTokenStream}
import java.io.FileInputStream

class Parser2( arg: String ) {
  val input = new ANTLRInputStream(new FileInputStream(arg))
  val lexer = new ToyLang2Lexer(input)
  val tokens = new CommonTokenStream(lexer)
  val parser = new ToyLang2Parser(tokens)
  val listener = new Listener
  parser.addParseListener(listener)
  val prog = parser.program
  println (listener.result)
}

这再简单不过了。
0

提醒一下，我已经想出了一个方法，可以直接在g4语法中嵌入scala操作。

antlr2scala_v0.1.tar.gz

我已经修改了这里找到的ANTLRv4Lexer.g4和ANTLRv4Parser.g4：

https://github.com/antlr/grammars-v4/tree/master/antlr4

允许像这样的特殊注释

//! <scala code>

首先在文件中添加以下内容以定义Scala监听器的头部：

在定义Scala监听器成员的规则列表之前，

并且在规则替代项之前或之后，为每个替代项指定进入和退出操作（必须加标签）。

基于这种修改后的格式，我开发了一个工具，可以从特殊注释中提取和打包Scala监听器的代码。

实际上，具有Scala操作的扩展文件如下所示：

//! // scala listener header
//! package toylang.parser.antlr
//! import toylang.ast._
//! import scala.collection.JavaConversions._

grammar ToyLang;

@lexer::header{
package toylang.parser.antlr;
}

@parser::header{
package toylang.parser.antlr;
import toylang.ast.*; // import scala ast symbols
}

//! // scala listener members
//! // stores the result of a successfull parse
//! var result: Option[List[Stmt]] = None 

program 
locals [scala.collection.immutable.List<Stmt> result]
    : sl+=defStmt sl+=defStmt* EOF # ProgramRule
        //! // exitAction for alternative
        //! ctx.result = (ctx.sl.view  map { _.result }).toList
        //! result = Some(ctx.result)

    ;

type 
locals [TypeExpr result]
    : 'int'  # IntType
        //! ctx.result = IntType
    | 'bool' # BoolType
        //! ctx.result = BoolType
    ;

defStmt 
locals[Stmt result]
    : 
        //! // entry action for alternative
        //! println("About to parse a statement!")
        //!
        id=ident ':' t=type  d=def? ';' # DefStmtRule
        //! // exit action for alternative
        //! val d = ctx.d match {
        //!   case null => None
        //!   case e@_ => Some(e.result)
        //! }
        //! ctx.result = DefStmt(ctx.id.result, ctx.t.result, d)
    ; 

def
locals [Expr result]
    : op=DEFINE e=expr  # DefRule
        //! ctx.result = ctx.e.result
    ;

expr 
locals[Expr result]
    : e=boolNum  # BoolNumExpr
        //! ctx.result = ctx.e.result

    | e=intNum   # IntNumxpr
        //! ctx.result = ctx.e.result

    | e=ident    # IdentExpr
        //! ctx.result = ctx.e.result

    | op='(' e=expr ')' # ParenExpr
        //! ctx.result = ctx.e.result

    | op=(ADD|SUB) e=expr # UnopArithExpr
        //! import ToyLangParser.{ADD, SUB}
        //!  val op = ctx.op.getType match {
        //!  case ADD => Plus
        //!  case SUB => Minus
        //! }
        //! ctx.result = op(ctx.e.result)

    |<assoc=right> l=expr op=CARRET r=expr  # PowerExpr
        //! ctx.result = Pow(ctx.l.result, ctx.r.result)

    |<assoc=left> l=expr op=(STAR|SLASH) r=expr # MulDivExpr
        //! import ToyLangParser.{STAR, SLASH}
        //!  val op = ctx.op.getType match {
        //!  case STAR => Mul
        //!  case SLASH => Div
        //! }
        //! ctx.result = op(ctx.l.result, ctx.r.result) 

    |<assoc=left> l=expr op=(ADD|SUB) r=expr # AddSubExpr
        //! import ToyLangParser.{ADD, SUB}
        //!  val op = ctx.op.getType match {
        //!  case ADD => Add
        //!  case SUB => Sub
        //! }
        //! ctx.result = op(ctx.l.result, ctx.r.result) 

    | l=expr op=(NEQ|EQ|LT|LE|GT|GE) r=expr # RelExpr
        //! import ToyLangParser.{NEQ,EQ,LT,LE,GT,GE}
        //!  val op = ctx.op.getType match {
        //!  case NEQ => Neq
        //!  case EQ => Eq
        //!  case LT => Lt
        //!  case GT => Gt
        //!  case LE => Le
        //!  case GE => Ge
        //! }
        //! ctx.result = op(ctx.l.result, ctx.r.result) 

    | op=NOT e=expr   # NotExpr
        //! ctx.result = Not(ctx.e.result)

    |<assoc=left> l=expr op=AND r=expr # AndExpr
        //! ctx.result = And(ctx.l.result, ctx.r.result)

    |<assoc=left> l=expr op=OR r=expr  # OrExpr
        //! ctx.result = Or(ctx.l.result, ctx.r.result)

    |<assoc=left> l=expr op=IMPLIES r=expr # ImpliesExpr
        //! ctx.result = Implies(ctx.l.result, ctx.r.result)

    | IF c=expr THEN t=expr ei+=elsif* ELSE e=expr  # IteExpr
        //! val elsifList = ctx.ei.view  map { _.result } 
        //! ctx.result = Ite(ctx.c.result, 
        //!                  ctx.t.result, 
        //!                  elsifList.toList, 
        //!                  ctx.e.result)
   ;

elsif 
locals [Elsif result]
    : op=ELSIF c=expr THEN t=expr # ElsifRule
        //! ctx.result = Elsif(ctx.c.result, ctx.t.result)
    ;

ident
locals [Ident result]
    : id=IDENT # IdentRule
        //! ctx.result = Ident(ctx.id.getText)
    ;

intNum
locals [IntNum result]
    : num=INT_NUM # IntNumRule
        //! ctx.result = IntNum(ctx.num.getText)
    ;

boolNum
locals [BoolNum result]
    : num=(TRUE | FALSE) # BoolNumRule
        //! ctx.result = BoolNum(ctx.num.getText)

    ;

COMMENT: (EOL | MLC) -> skip ;
fragment MLC: '/*' ( COMMENT | . )*? '*/' ;
fragment EOL: '//' .*? '\n' ;

LT: '<' ;
LE: '<=' ;
GT: '>' ;
GE: '>=' ;
EQ: '=' ;
NEQ: '!=' ;
ADD: '+';
AND: 'and';
DEFINE: ':=';
CARRET: '^';
ELSE: 'else';
ELSIF: 'elsif';
FALSE: 'false';
IF: 'if';
IMPLIES: 'implies';
KW_BOOL: 'bool';
KW_INT: 'int';
NOT: 'not';
OR: 'or';
SLASH: '*';
STAR: '*';
SUB: '-';
THEN: 'then';
TRUE: 'true';
INT_NUM :'0' |[1-9][0-9]* ; 
IDENT:[_a-zA-Z][_a-zA-Z0-9]* ;
WS: [ \t\f\r\n]+ -> skip;

提取的监听器看起来像这样：
// !!! DO NOT EDIT!!! 
// Code generated from grammar ToyLang by antlr4scala
// 

 // scala listener header
 package toylang.parser.antlr
 import toylang.ast._
 import scala.collection.JavaConversions._


class  Listener extends ToyLangBaseListener {

     // scala listener members
     // stores the result of a successfull parse
     var result: Option[List[Stmt]] = None 


    override def enterDefStmtRule( ctx: ToyLangParser.DefStmtRuleContext ): Unit = {
         // entry action for alternative
         println("About to parse a statement!")

    }


    override def exitProgramRule( ctx: ToyLangParser.ProgramRuleContext ): Unit = {
         // exitAction for alternative
         ctx.result = (ctx.sl.view  map { _.result }).toList
         result = Some(ctx.result)
    }


    override def exitIntType( ctx: ToyLangParser.IntTypeContext ): Unit = {
         ctx.result = IntType
    }


    override def exitBoolType( ctx: ToyLangParser.BoolTypeContext ): Unit = {
         ctx.result = BoolType
    }


    override def exitDefStmtRule( ctx: ToyLangParser.DefStmtRuleContext ): Unit = {
         // exit action for alternative
         val d = ctx.d match {
           case null => None
           case e@_ => Some(e.result)
         }
         ctx.result = DefStmt(ctx.id.result, ctx.t.result, d)
    }


    override def exitDefRule( ctx: ToyLangParser.DefRuleContext ): Unit = {
         ctx.result = ctx.e.result
    }


    override def exitBoolNumExpr( ctx: ToyLangParser.BoolNumExprContext ): Unit = {
            ctx.result = ctx.e.result
    }


    override def exitIntNumxpr( ctx: ToyLangParser.IntNumxprContext ): Unit = {
            ctx.result = ctx.e.result
    }


    override def exitIdentExpr( ctx: ToyLangParser.IdentExprContext ): Unit = {
            ctx.result = ctx.e.result
    }


    override def exitParenExpr( ctx: ToyLangParser.ParenExprContext ): Unit = {
            ctx.result = ctx.e.result
    }


    override def exitUnopArithExpr( ctx: ToyLangParser.UnopArithExprContext ): Unit = {
         import ToyLangParser.{ADD, SUB}
          val op = ctx.op.getType match {
          case ADD => Plus
          case SUB => Minus
         }
         ctx.result = op(ctx.e.result)
    }


    override def exitPowerExpr( ctx: ToyLangParser.PowerExprContext ): Unit = {
         ctx.result = Pow(ctx.l.result, ctx.r.result)
    }


    override def exitMulDivExpr( ctx: ToyLangParser.MulDivExprContext ): Unit = {
         import ToyLangParser.{STAR, SLASH}
          val op = ctx.op.getType match {
          case STAR => Mul
          case SLASH => Div
         }
         ctx.result = op(ctx.l.result, ctx.r.result) 
    }


    override def exitAddSubExpr( ctx: ToyLangParser.AddSubExprContext ): Unit = {
         import ToyLangParser.{ADD, SUB}
          val op = ctx.op.getType match {
          case ADD => Add
          case SUB => Sub
         }
         ctx.result = op(ctx.l.result, ctx.r.result) 
    }


    override def exitRelExpr( ctx: ToyLangParser.RelExprContext ): Unit = {
         import ToyLangParser.{NEQ,EQ,LT,LE,GT,GE}
          val op = ctx.op.getType match {
          case NEQ => Neq
          case EQ => Eq
          case LT => Lt
          case GT => Gt
          case LE => Le
          case GE => Ge
         }
         ctx.result = op(ctx.l.result, ctx.r.result) 
    }


    override def exitNotExpr( ctx: ToyLangParser.NotExprContext ): Unit = {
         ctx.result = Not(ctx.e.result)
    }


    override def exitAndExpr( ctx: ToyLangParser.AndExprContext ): Unit = {
         ctx.result = And(ctx.l.result, ctx.r.result)
    }


    override def exitOrExpr( ctx: ToyLangParser.OrExprContext ): Unit = {
         ctx.result = Or(ctx.l.result, ctx.r.result)
    }


    override def exitImpliesExpr( ctx: ToyLangParser.ImpliesExprContext ): Unit = {
         ctx.result = Implies(ctx.l.result, ctx.r.result)
    }


    override def exitIteExpr( ctx: ToyLangParser.IteExprContext ): Unit = {
         val elsifList = ctx.ei.view  map { _.result } 
         ctx.result = Ite(ctx.c.result, 
                          ctx.t.result, 
                          elsifList.toList, 
                          ctx.e.result)
    }


    override def exitElsifRule( ctx: ToyLangParser.ElsifRuleContext ): Unit = {
         ctx.result = Elsif(ctx.c.result, ctx.t.result)
    }


    override def exitIdentRule( ctx: ToyLangParser.IdentRuleContext ): Unit = {
         ctx.result = Ident(ctx.id.getText)
    }


    override def exitIntNumRule( ctx: ToyLangParser.IntNumRuleContext ): Unit = {
         ctx.result = IntNum(ctx.num.getText)
    }


    override def exitBoolNumRule( ctx: ToyLangParser.BoolNumRuleContext ): Unit = {
         ctx.result = BoolNum(ctx.num.getText)
    }


}

原始的ANTLR 4.4仍然可以用于从扩展的g4文件生成java词法分析器和解析器，所生成的监听器可以在scala内部附加到java解析器上。

/ Rémi

0

您可以使用parser.program调用的返回值，将解析器结果转换为任何数据结构。我已经尝试过这种方法，并发现它比访问者或侦听器简单得多，因为这是我实际期望获得解析器结果的地方。

是的，ANTLR生成的解析树可以遍历以生成任何内容，但是如果语言很大，则需要编写大量样板代码。将操作嵌入语法中允许自动生成此样板代码，因此我提出了这个解决方案。您甚至可以使用我的翻译器生成单个Scala监听器，如果需要对解析树进行多次通行，则可以将操作委托给多个不同的处理器。 - remi
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接