如何在 StandardTokenParsers 中定义正则表达式来识别路径？

Question

我正在编写一个解析器，我想在其中解析如下算术表达式： /hdfs://xxx.xx.xx.x:xxxx/path1/file1.jpg+1 我想解析它，将中缀更改为后缀并进行计算。我也使用了 code in another discussion 的一部分的帮助。

 class InfixToPostfix extends StandardTokenParsers {
 import lexical._

 def regexStringLit(r: Regex): Parser[String] = acceptMatch(
 "string literal matching regex " + r,
 { case  StringLit(s)  if r.unapplySeq(s).isDefined => s })
 def pathIdent: Parser[String] =regexStringLit("/hdfs://([\d\.]+):(\d+)/([\w/]+/(\w+\.\w+))".r)
 lexical.delimiters ++= List("+","-","*","/", "^","(",")",",")
 def value :Parser[Expr] = numericLit ^^ { s => Number(s) }
def variable:Parser[Expr] =  pathIdent ^^ { s => Variable(s) }
def parens:Parser[Expr] = "(" ~> expr <~ ")"

def argument:Parser[Expr] = expr <~ (","?)
def func:Parser[Expr] = ( pathIdent ~ "(" ~ (argument+) ~ ")" ^^ { case f ~ _ ~ e ~ _ => Function(f, e) })

def term = (value | parens | func | variable)

// Needed to define recursive because ^ is right-associative
def pow :Parser[Expr] = ( term ~ "^" ~ pow ^^ {case left ~ _ ~ right => BinaryOperator(left, "^", right) }|
            term)
def factor = pow * ("*" ^^^ { (left:Expr, right:Expr) => BinaryOperator(left, "*", right) } |
                    "/" ^^^ { (left:Expr, right:Expr) => BinaryOperator(left, "/", right) } )
def sum =  factor * ("+" ^^^ { (left:Expr, right:Expr) => BinaryOperator(left, "+", right) } |
                    "-" ^^^ { (left:Expr, right:Expr) => BinaryOperator(left, "-", right) } )
def expr = ( sum | term )

def parse(s:String) = {

   val tokens = new lexical.Scanner(s)
    phrase(expr)(tokens)
}

//和其余代码

我在的帮助下解决了以下错误：

      ScalaParser.scala:192: invalid escape character
  [error]     def pathIdent: Parser[String] =regexStringLit("/hdfs://([\d\.]+):(\d+)/([\w/]+/(\w+\.\w+))".r)
  [error]                                                               ^
  [error] ScalaParser.scala:192: invalid escape character
  [error]     def pathIdent: Parser[String] =regexStringLit("/hdfs://([\d\.]+):(\d+)/([\w/]+/(\w+\.\w+))".r)
   [error]                                                                ^
   [error] ScalaParser.scala:192: invalid escape character
   [error]     def pathIdent: Parser[String] =regexStringLit("/hdfs://([\d\.]+):(\d+)/([\w/]+/(\w+\.\w+))".r)
   [error]                                                                        ^

随着pathIdent的变化为：

  def pathIdent: Parser[String] =regexStringLit("/hdfs://([\d.]+):(\d+)/([\w/]+/(\w+\.w+))".r)

现在我收到一个运行时间错误，上面写着：

 [1.1] failure: string literal matching regex /hdfs://([\d\.]+):(\d+)/([\w/]+/(\w+\.\w+)) expected

/hdfs://111.33.55.2:8888/folder1/p.a3d+1
^

它使用 JavaTokenParsers 工作，但随着当前的变化，我不得不使用 StandardTokenParsers。

Answer 1

在双引号字符串中，反斜杠是转义字符。如果你想在双引号字符串中使用文字反斜杠，你必须将它转义，因此 "\d" 应该是 "\d"。

此外，您不需要转义字符 class 中的正则表达式点，因为点对字符 class 没有特殊含义。所以 "[\d.]" 应该只是 "[\d.]".

您也可以使用原始插值器或使用三重引号的多行字符串文字来放弃所有这些转义业务。

如何在 StandardTokenParsers 中定义正则表达式来识别路径？

How to define a Regex in StandardTokenParsers to identify path?

regex

scala

parsing

lexical-analysis