¿Retroceso en los combinadores scala parser?

Question

Parece que los combinadores de analizadores scala no retroceden. Tengo una gramática (ver abajo), que no puede analizar el siguiente "prop" correctamente:

copy in to out . 

Eso debería ser fácil de analizar con retroceso:

stmt: (to out(copy in)) 

o me estoy perdiendo algo?

Analizador:

type ExprP = Parser[Expr] 
type ValueP = Parser[ValExpr] 
type CallP = Parser[Call] 
type ArgsP = Parser[Seq[Expr]] 

val ident  = "[a-zA-Z\\+\\-\\*/%><\\\\\\=]+".r 
val sqstart = "\\["       .r 
val sqend  = "\\]"       .r 
val del  = ","       .r 
val end  = "\\."       .r 

def stmt: ExprP  = expr <~ end 
def expr: ExprP  = ucall | call | value 
def value: ValueP = ident ^^ {str => IdentExpr(str)} 
def call: CallP  = (args ~ ident ~ expr) ^^ {case args ~ method ~ upon => Call(args, method, upon)} 
def ucall: CallP  = (ident ~ expr) ^^ {case method ~ upon => Call(Seq(), method, upon)} 
def args: ArgsP  = advargs | smplargs 
def smplargs: ArgsP = expr ^^ {e => Seq(e)} 
def advargs: ArgsP = (sqstart ~> repsep(expr, del) <~ sqend) ^^ {seq => seq} 

Answer 1

Desea utilizar PackratParsers en 2.8. Creo que el analizador packrat es el único analizador de retroceso.

Editar: a partir de mediados de año 2015, debe utilizar fastparse en su lugar. No solo es mucho más rápido, sino también más fácil de usar (especialmente cuando se construyen estructuras de datos a partir del análisis sintáctico).

Answer 2

Tu problema no es retroceder. El operador estándar | en scala.util.parsing.combinator hará un backtracking. Su problema es recursión a la izquierda (expr → call → args → smplargs → expr). El análisis de Packrat puede ayudar con eso.