Wie man eine Zeichenkette auf mehrfachen regulären Ausdrücken teilt, während man die aufspaltenden Zeichen behält

Question

Ich schreibe einen Lexer/Scanner zum ersten Mal, und habe ein Problem beim Aufteilen der Eingabezeichenkette gehabt. Beispiel:

val result = "func add(Num x, Num y) = x+y;".split(???) 
result == Array("func", "add", "(", "Num", "x", ",", "Num", "y", ")", "=", "x", "+", "y", ";") 

Aber das Problem ist, dass ich nicht einfach auf Leerzeichen aufteilen, also nicht add von ( zum Beispiel trennen würde tun.

Irgendwelche Hilfe dabei?

Answer 1

Dies wird Ihnen eine Reihe von leeren Elementen, die Ihre EE zu behandeln haben, aber Hinzufügen von Word-Grenze - \b - sollte es tun.

Überprüfen Sie example at regex101.

I.e. ...split('\s|\b') (oder /\s|\b/).

Grüße

Answer 2

Blick in http://www.scala-lang.org/api/rc/index.html#scala.util.parsing.combinator.RegexParsers

Hier ist ein unfertiges Beispiel:

import scala.util.parsing.combinator.RegexParsers 

trait Element 

case class Function(name: String, 
                    params:Map[String, String], 
                    expression:Seq[String]) extends Element 

case class Class(name: String, 
                 params: Map[String,String], 
                 body: Seq[String]) extends Element 

object LanguageParser extends RegexParsers { 

  val name: Parser[String] = ".*".r 

  val `type`: Parser[String] = ??? 

  val parameters: Parser[Map[String,String]] = "(" ~> (`type` ~ name).* <~")" ^^ { 
    case t => (t map { 
      case a ~ b => a -> b 
    }).toMap 
  } 

  val expression: Parser[Seq[String]] = ??? 

  val function: Parser[Function] = 
    "func " ~> name ~ parameters ~ "="~ expression ^^ { 
      case name ~  params ~ _ ~ expr => Function(name, params, expr) 
    } 
   
  val `class`: Parser[Class] = 
    "class " ~> name ~ parameters ~ "{" ~ expression ~ "}" ^^ { 
      case name ~  params ~ _ ~ expr ~_ => Class(name, params, expr) 
    } 

  val topLevelParsers: Parser[Seq[Element]] = 
    function | 
      `class` | 
      value | 
      ifelse 

  def parse(s: String): Seq[Element] = parseAll(topLevelParsers, s.trim) getOrElse 
    (throw newIllegalArgumentException("Could not parse the given string: " + s.trim)) 

  def parseAll(s: String):Seq[Element] = 
    s split ";" flatMap parse 
} 

Prost