gistfile1.txt

object Tokenizer extends RegexParsers {

  val quoteSymbol = """\\\""""

  trait Element
  case class ParElement(value: List[Element]) extends Element
  case class CurElement(value: List[Element]) extends Element
  trait Value extends Element
  case class WholeInteger(value: String) extends Value
  case class Decimal(value: String) extends Value
  case class QuotedValue(value: String) extends Value


  case class OuterMarker(endsWith : String, size: Int)
  case class Level(innerMarker: String, depth: Int, outerMarker: OuterMarker = OuterMarker("",0))
  case class CloseInput(l:Level, elems : List[Element])

  def makeLevel(l: Level,innerMarker: String) : Level = {
    val newDepth = l.depth + 1
    println(innerMarker)
    newDepth match {
      case 0 => Level(innerMarker ,newDepth,OuterMarker(innerMarker,2^newDepth))
      case _ => Level(innerMarker,newDepth,OuterMarker(innerMarker,2^newDepth))
    }
  }

  def marker = "[\\\\|\"]+".r
  def openCurly(l: Level):Parser[Level] = opt(marker) <~ "{" ^^ { x=> val out = makeLevel(l,x.getOrElse("")); println("opencur") ;out }
  def closeCurly(l: CloseInput): Parser[List[Element]] = "}" <~ l.l.innerMarker ^^ { x=>l.elems }
  def openPar(l: Level) : Parser[Level] = opt(marker) <~ "("^^ {  x=> println("openpar") ;makeLevel(l,x.getOrElse("")) }
  def closePar(l: CloseInput) : Parser[List[Element]] = ")"  <~ l.l.innerMarker ^^ {x=>l.elems}

  def signedIntegral = "[+|-]?\\d+".r ^^ { x=> println(x); WholeInteger(x) }
  def decimal = "[+|-]?\\d+\\.\\d+".r ^^ { Decimal(_) }

  def quotedValueInternal(in: Input) = {

  }
  def quote = marker ^^ { x=>println("marker");x }
  def quotedValue(l:Level) = quote >> quotedValueInternal <~ quote ^^ { x=> println("quoted value"); QuotedValue(x)}

  def numeric : Parser[Value] =  decimal | signedIntegral
  def element(l:Level) : Parser[Element] = (parElement(l) | curElement(l) | numeric | quotedValue(l:Level) ) ^^ { x=> println(x); x}

  def body(l: Level): Parser[CloseInput] = repsep(element(l), ",") ^^ { x=> CloseInput(l,x)}

  def curElement(l : Level) = openCurly(l) >> body >> closeCurly ^^ { println("uno"); CurElement(_) }
  def parElement(l: Level) = openPar(l) >> body >> closePar ^^ { ParElement(_) }


  def tokenize: Parser[ List[Element] ] = rep(curElement(Level("",-1)) | parElement(Level("",-1)))

  def apply(input : String) = {
    parseAll(tokenize,new scala.util.parsing.input.CharArrayReader(input.toCharArray));
  }
}