Scala IF-ELSEIF-ELSE 用于控制流的简单解析器组合器

Question

我正在编写一个解析器组合器来解析简单的控制流语句并执行一些代码。语言的结构大致是这样的-

val resultId = 200
  val s = s"""(IF $resultId == 100 GOTO NODE-1-->NODE-2) (ELSE IF $resultId > 100 GOTO NODE-1-->NODE-3) (ELSE GOTO NODE-1-->NODE-4)""".stripMargin
  private val result= new ConditionalParserCombinator().run(s)

例如，在上面的场景中，我应该得到 GOTO NODE-1-->NODE-3 而不是在评估 else 表达式后得到 false，组合器代码概述如下：

final class ConditionalParserCombinator extends JavaTokenParsers with ParserCombinatorLike {
    def IF = "IF"
    def ELSE = "ELSE"
    def ELSEIF = ELSE ~ IF
    def NULL = "NULL"
    def GOTO = "GOTO"
    def node_id = wholeNumber | floatingPointNumber | stringLiteral
    def NODE = "NODE" ~ "-" ~ node_id ^^ (e ⇒ NodeExpression(e._2))
    def EDGE = NODE ~ "-->" ~ NODE ^^ (e ⇒ EdgeExpression(e._1._1, e._2))
    def lhs = ident | wholeNumber | floatingPointNumber | stringLiteral
    def rhs = ident | wholeNumber | floatingPointNumber | stringLiteral | NULL
    def operator = "==" | "*" | "/" | "||" | "&&" | ">" | "<" | ">=" | "<="
    def block = GOTO ~ EDGE
    def expression_block = lhs ~ operator ~ rhs ~ block ^^ {
      case lhs ~ operator ~ rhs ~ block ⇒ ExpressionBlock(lhs, rhs, operator, block._2)
    }
    def ifExpression = IF ~ expression_block ^^ (e ⇒ e._2.operator match {
      case "==" ⇒ if (e._2.lhs == e._2.rhs) Block(e._2.block) else false
      case ">" ⇒ if (e._2.lhs > e._2.rhs) Block(e._2.block) else false
      case "<" ⇒ if (e._2.lhs < e._2.rhs) Block(e._2.block) else false
      case _ ⇒ false
    })
    def elseIFExpression = ELSEIF ~ expression_block ^^ (e ⇒ e._2.operator match {
      case "==" ⇒ if (e._2.lhs == e._2.rhs) Block(e._2.block) else false
      case ">" ⇒ if (e._2.lhs > e._2.rhs) {
        println("matched elseif")
        Block(e._2.block)
      } else false
      case "<" ⇒ if (e._2.lhs < e._2.rhs) Block(e._2.block) else false
      case _ ⇒ false
    })
    def elseExpression = ELSE ~ block ^^ (e ⇒ Block(e._2._2))
    override def grammar = "(" ~> log(ifExpression)("ifexpression") <~ ")" ~!
      "(" ~> log(elseIFExpression)("elseifexpression") <~ ")" ~!
      "(" ~> log(elseExpression)("elseexpression") <~ ")"
  }

我正在打印 result.get，结果是 false。

** 其他详细信息 - Block、ExpressionBlock 都是大小写类对我稍后可能做的一些事情很有用**

Answer 1

我认为将表达式解析为您可以理解的类型（意味着我为其定义了自定义 Product/Case 类）然后对其求值更清晰 - 这是两件不同的事情。事后看来，我不确定为什么我会把两者混为一谈。这是有效的逻辑 -

def IF = "IF"
def ELSE = "ELSE"
def ELSEIF = ELSE ~ IF
def NULL = "NULL"
def GOTO = "GOTO"
def dataType: Parser[DataType] = "[" ~ "Integer" ~ "]" ^^ { e ⇒ DataType("", "Integer") }
def node_id = wholeNumber | floatingPointNumber | stringLiteral
def NODE = "NODE" ~ "-" ~ node_id ^^ (e ⇒ ParseableNode(e._2, DataType({}, "Unit")))
def EDGE = NODE ~ "-->" ~ NODE ^^ (e ⇒ EdgeExpression(e._1._1, e._2))
def lhs = ident | wholeNumber | floatingPointNumber | stringLiteral
def rhs = ident | wholeNumber | floatingPointNumber | stringLiteral | NULL
def operator = "==" | "*" | "/" | "||" | "&&" | ">" | "<" | ">=" | "<="
def block = GOTO ~ EDGE
def expression_block(expType: ConditionalKind) = dataType ~ lhs ~ operator ~ rhs ~ block ^^ {
  case dataType ~ lhs ~ operator ~ rhs ~ block ⇒ ExpressionBlock(ParseableNode(lhs, dataType), ParseableNode(rhs, dataType), operator, block._2, expType)
}
def ifExpression = IF ~ expression_block(ConditionalKind("IF")) ^^ {
  case "IF" ~ expression_block ⇒ ExpressionBlock(expression_block.lhs, expression_block.rhs, expression_block.operator, expression_block.block, expression_block.conditionalKind)
}
def elseIFExpression = ELSEIF ~ expression_block(ConditionalKind("ELSEIF")) ^^ {
  case "ELSE" ~ "IF" ~ expression_block ⇒ ExpressionBlock(expression_block.lhs, expression_block.rhs, expression_block.operator, expression_block.block, expression_block.conditionalKind)
}
def elseExpression = ELSE ~ block ^^ { case "ELSE" ~ block ⇒ Block(block._2) }
override def grammar = log(ifExpression)("ifexpression") ~ log(elseIFExpression)("elseifexpression") ~ log(elseExpression)("elseexpression") ^^ {
  case ifExpression ~ elseIFExpression ~ elseExpression ⇒
    ConditionalExpressions(List(ifExpression, elseIFExpression), elseExpression)
}

上面的逻辑在这样计算后有效 -

object BasicSelectorExpressionEvaluator extends EvaluatorLike {

override def eval(parseable: Parseable) = parseable match {
  case ConditionalExpressions(ifElseIfs, otherwise) ⇒
    val mappedIfElseIfs: immutable.Seq[Block] = ifElseIfs.map { e ⇒
      println(s"e ==>$e")
      e.operator match {
        case "==" ⇒ if (e.lhs == e.rhs) {
          println("mached ==")
          Block(e.block)
        } else Block.Unit
        case "<" ⇒ if (e.lhs.value.toInt < e.rhs.value.toInt) {
          println("matched <")
          Block(e.block)
        } else Block.Unit
        case ">" ⇒ if (e.lhs.value.toInt > e.rhs.value.toInt) {
          println("matched >")
          Block(e.block)
        } else Block.Unit
        case "<=" ⇒ if (e.lhs.value.toInt <= e.rhs.value.toInt) {
          println("mached <=")
          Block(e.block)
        } else Block.Unit
        case ">=" ⇒ if (e.lhs.value.toInt >= e.rhs.value.toInt) {
          println("mached >=")
          Block(e.block)
        } else Block.Unit
      }
    }
    val filteredMappedIFElseIfs = mappedIfElseIfs.filterNot(e ⇒ e.equals(Block.Unit))
    println(s"filteredMappedIFElseIfs == $filteredMappedIFElseIfs")
    if (filteredMappedIFElseIfs.nonEmpty) PResult(filteredMappedIFElseIfs.head.block) else PResult(otherwise.block)
}

}

所以上面可以解析这个语法-

val s = s""" IF [Integer] $resultId == 100 GOTO NODE-1-->NODE-2 ELSE IF [Integer] $resultId > 100 GOTO NODE-1-->NODE-3 ELSE GOTO NODE-1-->NODE-4""".stripMargin

可以做得更好，例如通过在每个 If 上嵌入数据类型，语法似乎违反了 DRY，但我想人们可以从中得出一些东西。

编辑 - 另请注意 - 这个 toInt 东西有点难看，需要更好地设计，一旦我这样做，我可能会 post 更新。我需要重写所有语法，现在一切正常 - suggestions/improvements 欢迎，仍在学习。

Scala IF-ELSEIF-ELSE 用于控制流的简单解析器组合器

Scala IF-ELSEIF-ELSE Simple parser combinator for control flow

scala

parser-combinators