java - ANTLR + 斯卡拉 : ideas for improvements?-6ren

java - ANTLR + 斯卡拉 : ideas for improvements?

转载作者：塔克拉玛干更新时间：2023-11-02 20:02:29

我正试图找到一种在 Scala 领域中集成 antlr 解析器的方法。

我试过使用 scala 编码的访问者从解析树构建 scala 对象，但是没有统一返回类型的限制。

所以我冒险决定使用 Scala 类的 Java 接口(interface)直接从解析器操作构建 Scala 对象。

这篇博文很有帮助:

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 语法与调用 scala 构造函数的 java Action

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 是在转换为 scala 列表之前映射到 java 列表的操作的接口(interface).

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)
}

欢迎任何改进 extract-results-from-contex-java-to-scala 列表转换的想法。让它完全通用会很棒，或许可以使用 java 反射 API。理想情况下，我想使用一条语句来表示:从此列表的每个 antlr 规则上下文对象(或标记)中提取名为“foo”的字段，并将结果转换为 Scala 列表。

我已经在网上找遍了，但没有找到关于如何做到这一点的指南。

问候，

最佳答案

答案一直在我眼前，我太盲目了，看不到它:听众。

使用本地定义更新了语法，以便可以存储 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)
}

这再简单不过了。

关于java - ANTLR + 斯卡拉 : ideas for improvements?，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27023457/

文章推荐： android - 在 Mortar 屏幕内获取 Activity 的推荐方法？

文章推荐： ios - UINavigationController 自定义模式转换，导航栏太小

文章推荐： ios - 测试人员无法使用 testFlight 安装应用程序

文章推荐： java - 在我的新 GUI 中调用我的 run 方法后，如何返回类？

java - Java 方法如何检索属于该特定方法的方法对象？ ( java )
我正在编写一个具有以下签名的 Java 方法。 void Logger(Method method, Object[] args); 如果一个方法(例如 ABC() )调用此方法 Logger，它应该
java - (Java) Java 找不到我的图像文件
我是 Java 新手。我的问题是我的 Java 程序找不到我试图用作的图像文件一个 JButton。 (目前这段代码什么也没做，因为我只是得到了想要的外观第一的)。这是我的主课代码: packag
java - java Java 有手动垃圾回收吗？
好的，今天我在接受采访，我已经编写 Java 代码多年了。采访中说“Java 垃圾收集是一个棘手的问题，我有几个 friend 一直在努力弄清楚。你在这方面做得怎么样？”。她是想骗我吗？还是我的一生都
java - Java 之谜 - Java
我的 friend 给了我一个谜语让我解开。它是这样的: There are 100 people. Each one of them, in his turn, does the following
java - Java 字节码是否兼容不同版本的 Java？
如果我将使用 Java 5 代码的应用程序编译成字节码，生成的 .class 文件是否能够在 Java 1.4 下运行？如果后者可以工作并且我正在尝试在我的 Java 1.4 应用程序中使用 Jav
java - Java 缺少无符号原始类型是 Java 平台的特征还是 Java 语言的特征？
有关于why Java doesn't support unsigned types的问题以及一些关于处理无符号类型的问题。我做了一些搜索，似乎 Scala 也不支持无符号数据类型。限制是Java和S
java - Java 7 的 Java 字节码可以在其他版本的 Java 中工作吗
我只是想知道在一个 java 版本中生成的字节码是否可以在其他 java 版本上运行最佳答案通常，字节码无需修改即可在较新版本的 Java 上运行。它不会在旧版本上运行，除非您使用特殊参数 (
java -cp 。 test.java 与 java test.java
我有一个关于在命令提示符下执行 java 程序的基本问题。在某些机器上我们需要指定 -cp 。 (类路径)同时执行java程序 (test为java文件名与.class文件存在于同一目录下) jav
java - 使用 Java (Java EE/Java SE) 的数据库应用程序设计模式
我已经阅读 StackOverflow 有一段时间了，现在我才鼓起勇气提出问题。我今年 20 岁，目前在我的家乡(罗马尼亚克卢日-纳波卡)就读 IT 大学。足以介绍:D。基本上，我有一家提供簿记应用
java - Java 中的解析可在 Java 中访问
我有 public JSONObject parseXML(String xml) { JSONObject jsonObject = XML.toJSONObject(xml); r
java - Java 中的解释性语言以及对 Java 方法的调用
我已经在 Java 中实现了带有动态类型的简单解释语言。不幸的是我遇到了以下问题。测试时如下代码: def main() { def ks = Map[[1, 2]].keySet()
java - java 序数 - Java I 类
一直提示输入 1 到 10 的数字 - 结果应将 st、rd、th 和 nd 添加到数字中。编写一个程序，提示用户输入 1 到 10 之间的任意整数，然后以序数形式显示该整数并附加后缀。 public
java - 如何从 Java 执行 Java？
我有这个 DownloadFile.java 并按预期下载该文件: import java.io.*; import java.net.URL; public class DownloadFile {
java - 延迟不适用于 java gui(java)
我想在 GUI 上添加延迟。我放置了 2 个 for 循环，然后重新绘制了一个标签，但这 2 个 for 循环一个接一个地执行，并且标签被重新绘制到最后一个。我能做什么？ for(int i=0;
java - Java 类中的硬编码 Java 列表
我正在对对象 Student 的列表项进行一些测试，但是我更喜欢在 java 类对象中创建硬编码列表，然后从那里提取数据，而不是连接到数据库并在结果集中选择记录。然而，自从我这样做以来已经很长时间了，
java - java 幕后对象创建(java 对象实例化)
我知道对象创建分为三个部分: 声明实例化初始化 classA{} classB extends classA{} classA obj = new classB(1,1); 实例化它必须使用
java - 车辆跟踪系统[java/Java EE]
我有兴趣使用 GPRS 构建车辆跟踪系统。但是，我有一些问题要问以前做过此操作的人: GPRS 是最好的技术吗？人们意识到任何问题吗？我计划使用 Java/Java EE - 有更好的技术吗？如果
java - 逆数组(Java)//逆数组(Java)
我可以通过递归方法反转数组，例如:数组={1,2,3,4,5} 数组结果={5,4,3,2,1}但我的结果是相同的数组，我不知道为什么，请帮助我。 public class Recursion { p
java - Java/Java EE 的构建和集成环境
有这样的标准方式吗？包括 Java源代码-测试代码- Ant 或 Maven联合单元持续集成(可能是巡航控制)ClearCase 版本控制工具部署到应用服务器最后我希望有一个自动构建和集成环境。
java - 我将如何从 java 程序打印文本？ ( java )
我什至不知道这是否可能，我非常怀疑它是否可能，但如果可以，您能告诉我怎么做吗？我只是想知道如何从打印机打印一些文本。有什么想法吗？最佳答案这里有更简单的事情。 import javax.swin

塔克拉玛干

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

java - ANTLR + 斯卡拉 : ideas for improvements?